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
  18 #ifdef __cplusplus
  19 /* SwigValueWrapper is described in swig.swg */
  20 template<typename T> class SwigValueWrapper {
  21   struct SwigMovePointer {
  22     T *ptr;
  23     SwigMovePointer(T *p) : ptr(p) { }
  24     ~SwigMovePointer() { delete ptr; }
  25     SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
  26   } pointer;
  27   SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
  28   SwigValueWrapper(const SwigValueWrapper<T>& rhs);
  29 public:
  30   SwigValueWrapper() : pointer(0) { }
  31   SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
  32   operator T&() const { return *pointer.ptr; }
  33   T *operator&() { return pointer.ptr; }
  34 };
  35
  36 template <typename T> T SwigValueInit() {
  37   return T();
  38 }
  39 #endif
  40
  41 /* -----------------------------------------------------------------------------
  42  *  This section contains generic SWIG labels for method/variable
  43  *  declarations/attributes, and other compiler dependent labels.
  44  * ----------------------------------------------------------------------------- */
  45
  46 /* template workaround for compilers that cannot correctly implement the C++ standard */
  47 #ifndef SWIGTEMPLATEDISAMBIGUATOR
  48 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
  49 #  define SWIGTEMPLATEDISAMBIGUATOR template
  50 # elif defined(__HP_aCC)
  51 /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
  52 /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
  53 #  define SWIGTEMPLATEDISAMBIGUATOR template
  54 # else
  55 #  define SWIGTEMPLATEDISAMBIGUATOR
  56 # endif
  57 #endif
  58
  59 /* inline attribute */
  60 #ifndef SWIGINLINE
  61 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
  62 #   define SWIGINLINE inline
  63 # else
  64 #   define SWIGINLINE
  65 # endif
  66 #endif
  67
  68 /* attribute recognised by some compilers to avoid 'unused' warnings */
  69 #ifndef SWIGUNUSED
  70 # if defined(__GNUC__)
  71 #   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
  72 #     define SWIGUNUSED __attribute__ ((__unused__))
  73 #   else
  74 #     define SWIGUNUSED
  75 #   endif
  76 # elif defined(__ICC)
  77 #   define SWIGUNUSED __attribute__ ((__unused__))
  78 # else
  79 #   define SWIGUNUSED
  80 # endif
  81 #endif
  82
  83 #ifndef SWIG_MSC_UNSUPPRESS_4505
  84 # if defined(_MSC_VER)
  85 #   pragma warning(disable : 4505) /* unreferenced local function has been removed */
  86 # endif
  87 #endif
  88
  89 #ifndef SWIGUNUSEDPARM
  90 # ifdef __cplusplus
  91 #   define SWIGUNUSEDPARM(p)
  92 # else
  93 #   define SWIGUNUSEDPARM(p) p SWIGUNUSED
  94 # endif
  95 #endif
  96
  97 /* internal SWIG method */
  98 #ifndef SWIGINTERN
  99 # define SWIGINTERN static SWIGUNUSED
 100 #endif
 101
 102 /* internal inline SWIG method */
 103 #ifndef SWIGINTERNINLINE
 104 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
 105 #endif
 106
 107 /* exporting methods */
 108 #if defined(__GNUC__)
 109 #  if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
 110 #    ifndef GCC_HASCLASSVISIBILITY
 111 #      define GCC_HASCLASSVISIBILITY
 112 #    endif
 113 #  endif
 114 #endif
 115
 116 #ifndef SWIGEXPORT
 117 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
 118 #   if defined(STATIC_LINKED)
 119 #     define SWIGEXPORT
 120 #   else
 121 #     define SWIGEXPORT __declspec(dllexport)
 122 #   endif
 123 # else
 124 #   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
 125 #     define SWIGEXPORT __attribute__ ((visibility("default")))
 126 #   else
 127 #     define SWIGEXPORT
 128 #   endif
 129 # endif
 130 #endif
 131
 132 /* calling conventions for Windows */
 133 #ifndef SWIGSTDCALL
 134 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
 135 #   define SWIGSTDCALL __stdcall
 136 # else
 137 #   define SWIGSTDCALL
 138 # endif
 139 #endif
 140
 141 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
 142 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
 143 # define _CRT_SECURE_NO_DEPRECATE
 144 #endif
 145
 146 /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
 147 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
 148 # define _SCL_SECURE_NO_DEPRECATE
 149 #endif
 150
 151 /* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
 152 #if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
 153 # define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
 154 #endif
 155
 156 /* Intel's compiler complains if a variable which was never initialised is
 157  * cast to void, which is a common idiom which we use to indicate that we
 158  * are aware a variable isn't used.  So we just silence that warning.
 159  * See: https://github.com/swig/swig/issues/192 for more discussion.
 160  */
 161 #ifdef __INTEL_COMPILER
 162 # pragma warning disable 592
 163 #endif
 164
 165
 166 #include <stdlib.h>
 167 #include <string.h>
 168 #include <stdio.h>
 169
 170
 171 /* Support for throwing C# exceptions from C/C++. There are two types:
 172  * Exceptions that take a message and ArgumentExceptions that take a message and a parameter name. */
 173 typedef enum {
 174   SWIG_CSharpApplicationException,
 175   SWIG_CSharpArithmeticException,
 176   SWIG_CSharpDivideByZeroException,
 177   SWIG_CSharpIndexOutOfRangeException,
 178   SWIG_CSharpInvalidCastException,
 179   SWIG_CSharpInvalidOperationException,
 180   SWIG_CSharpIOException,
 181   SWIG_CSharpNullReferenceException,
 182   SWIG_CSharpOutOfMemoryException,
 183   SWIG_CSharpOverflowException,
 184   SWIG_CSharpSystemException
 185 } SWIG_CSharpExceptionCodes;
 186
 187 typedef enum {
 188   SWIG_CSharpArgumentException,
 189   SWIG_CSharpArgumentNullException,
 190   SWIG_CSharpArgumentOutOfRangeException
 191 } SWIG_CSharpExceptionArgumentCodes;
 192
 193 typedef void (SWIGSTDCALL* SWIG_CSharpExceptionCallback_t)(const char *);
 194 typedef void (SWIGSTDCALL* SWIG_CSharpExceptionArgumentCallback_t)(const char *, const char *);
 195
 196 typedef struct {
 197   SWIG_CSharpExceptionCodes code;
 198   SWIG_CSharpExceptionCallback_t callback;
 199 } SWIG_CSharpException_t;
 200
 201 typedef struct {
 202   SWIG_CSharpExceptionArgumentCodes code;
 203   SWIG_CSharpExceptionArgumentCallback_t callback;
 204 } SWIG_CSharpExceptionArgument_t;
 205
 206 SWIG_CSharpException_t SWIG_csharp_exceptions[] = {
 207   { SWIG_CSharpApplicationException, NULL },
 208   { SWIG_CSharpArithmeticException, NULL },
 209   { SWIG_CSharpDivideByZeroException, NULL },
 210   { SWIG_CSharpIndexOutOfRangeException, NULL },
 211   { SWIG_CSharpInvalidCastException, NULL },
 212   { SWIG_CSharpInvalidOperationException, NULL },
 213   { SWIG_CSharpIOException, NULL },
 214   { SWIG_CSharpNullReferenceException, NULL },
 215   { SWIG_CSharpOutOfMemoryException, NULL },
 216   { SWIG_CSharpOverflowException, NULL },
 217   { SWIG_CSharpSystemException, NULL }
 218 };
 219
 220 SWIG_CSharpExceptionArgument_t SWIG_csharp_exceptions_argument[] = {
 221   { SWIG_CSharpArgumentException, NULL },
 222   { SWIG_CSharpArgumentNullException, NULL },
 223   { SWIG_CSharpArgumentOutOfRangeException, NULL }
 224 };
 225
 226 void SWIGUNUSED SWIG_CSharpSetPendingException(SWIG_CSharpExceptionCodes code, const char *msg) {
 227   SWIG_CSharpExceptionCallback_t callback = SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback;
 228   if ((size_t)code < sizeof(SWIG_csharp_exceptions)/sizeof(SWIG_CSharpException_t)) {
 229     callback = SWIG_csharp_exceptions[code].callback;
 230   }
 231   callback(msg);
 232 }
 233
 234 void SWIGUNUSED SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpExceptionArgumentCodes code, const char *msg, const char *param_name) {
 235   SWIG_CSharpExceptionArgumentCallback_t callback = SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback;
 236   if ((size_t)code < sizeof(SWIG_csharp_exceptions_argument)/sizeof(SWIG_CSharpExceptionArgument_t)) {
 237     callback = SWIG_csharp_exceptions_argument[code].callback;
 238   }
 239   callback(msg, param_name);
 240 }
 241
 242
 243 #ifdef __cplusplus
 244 extern "C"
 245 #endif
 246 SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionCallbacks_NDalic(
 247                                                 SWIG_CSharpExceptionCallback_t applicationCallback,
 248                                                 SWIG_CSharpExceptionCallback_t arithmeticCallback,
 249                                                 SWIG_CSharpExceptionCallback_t divideByZeroCallback,
 250                                                 SWIG_CSharpExceptionCallback_t indexOutOfRangeCallback,
 251                                                 SWIG_CSharpExceptionCallback_t invalidCastCallback,
 252                                                 SWIG_CSharpExceptionCallback_t invalidOperationCallback,
 253                                                 SWIG_CSharpExceptionCallback_t ioCallback,
 254                                                 SWIG_CSharpExceptionCallback_t nullReferenceCallback,
 255                                                 SWIG_CSharpExceptionCallback_t outOfMemoryCallback,
 256                                                 SWIG_CSharpExceptionCallback_t overflowCallback,
 257                                                 SWIG_CSharpExceptionCallback_t systemCallback) {
 258   SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback = applicationCallback;
 259   SWIG_csharp_exceptions[SWIG_CSharpArithmeticException].callback = arithmeticCallback;
 260   SWIG_csharp_exceptions[SWIG_CSharpDivideByZeroException].callback = divideByZeroCallback;
 261   SWIG_csharp_exceptions[SWIG_CSharpIndexOutOfRangeException].callback = indexOutOfRangeCallback;
 262   SWIG_csharp_exceptions[SWIG_CSharpInvalidCastException].callback = invalidCastCallback;
 263   SWIG_csharp_exceptions[SWIG_CSharpInvalidOperationException].callback = invalidOperationCallback;
 264   SWIG_csharp_exceptions[SWIG_CSharpIOException].callback = ioCallback;
 265   SWIG_csharp_exceptions[SWIG_CSharpNullReferenceException].callback = nullReferenceCallback;
 266   SWIG_csharp_exceptions[SWIG_CSharpOutOfMemoryException].callback = outOfMemoryCallback;
 267   SWIG_csharp_exceptions[SWIG_CSharpOverflowException].callback = overflowCallback;
 268   SWIG_csharp_exceptions[SWIG_CSharpSystemException].callback = systemCallback;
 269 }
 270
 271 #ifdef __cplusplus
 272 extern "C"
 273 #endif
 274 SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionArgumentCallbacks_NDalic(
 275                                                 SWIG_CSharpExceptionArgumentCallback_t argumentCallback,
 276                                                 SWIG_CSharpExceptionArgumentCallback_t argumentNullCallback,
 277                                                 SWIG_CSharpExceptionArgumentCallback_t argumentOutOfRangeCallback) {
 278   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback = argumentCallback;
 279   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentNullException].callback = argumentNullCallback;
 280   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentOutOfRangeException].callback = argumentOutOfRangeCallback;
 281 }
 282
 283
 284 /* Callback for returning strings to C# without leaking memory */
 285 typedef char * (SWIGSTDCALL* SWIG_CSharpStringHelperCallback)(const char *);
 286 SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback = NULL;
 287
 288 // keep argWidgetCs and argWidgetV so they're always available to DALi
 289 int argWidgetC = 1;
 290 char **argWidgetV = NULL;
 291
 292 #ifdef __cplusplus
 293 extern "C"
 294 #endif
 295 SWIGEXPORT void SWIGSTDCALL SWIGRegisterStringCallback_NDalic(SWIG_CSharpStringHelperCallback callback) {
 296   SWIG_csharp_string_callback = callback;
 297 }
 298
 299
 300 /* Contract support */
 301
 302 #define SWIG_contract_assert(nullreturn, expr, msg) if (!(expr)) {SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, msg, ""); return nullreturn; } else
 303
 304 /*  Errors in SWIG */
 305 #define  SWIG_UnknownError         -1
 306 #define  SWIG_IOError              -2
 307 #define  SWIG_RuntimeError         -3
 308 #define  SWIG_IndexError           -4
 309 #define  SWIG_TypeError            -5
 310 #define  SWIG_DivisionByZero       -6
 311 #define  SWIG_OverflowError        -7
 312 #define  SWIG_SyntaxError          -8
 313 #define  SWIG_ValueError           -9
 314 #define  SWIG_SystemError          -10
 315 #define  SWIG_AttributeError       -11
 316 #define  SWIG_MemoryError          -12
 317 #define  SWIG_NullReferenceError   -13
 318
 319
 320
 321 /* -----------------------------------------------------------------------------
 322  * director_common.swg
 323  *
 324  * This file contains support for director classes which is common between
 325  * languages.
 326  * ----------------------------------------------------------------------------- */
 327
 328 /*
 329   Use -DSWIG_DIRECTOR_STATIC if you prefer to avoid the use of the
 330   'Swig' namespace. This could be useful for multi-modules projects.
 331 */
 332 #ifdef SWIG_DIRECTOR_STATIC
 333 /* Force anonymous (static) namespace */
 334 #define Swig
 335 #endif
 336 /* -----------------------------------------------------------------------------
 337  * director.swg
 338  *
 339  * This file contains support for director classes so that C# proxy
 340  * methods can be called from C++.
 341  * ----------------------------------------------------------------------------- */
 342
 343 #if defined(DEBUG_DIRECTOR_OWNED)
 344 #include <iostream>
 345 #endif
 346 #include <string>
 347 #include <exception>
 348
 349 namespace Swig {
 350   /* Director base class - not currently used in C# directors */
 351   class Director {
 352   };
 353
 354   /* Base class for director exceptions */
 355   class DirectorException : public std::exception {
 356   protected:
 357     std::string swig_msg;
 358
 359   public:
 360     DirectorException(const char *msg) : swig_msg(msg) {
 361     }
 362
 363     DirectorException(const std::string &msg) : swig_msg(msg) {
 364     }
 365
 366     virtual ~DirectorException() throw() {
 367     }
 368
 369     const char *what() const throw() {
 370       return swig_msg.c_str();
 371     }
 372   };
 373
 374   /* Pure virtual method exception */
 375   class DirectorPureVirtualException : public DirectorException {
 376   public:
 377     DirectorPureVirtualException(const char *msg) : DirectorException(std::string("Attempt to invoke pure virtual method ") + msg) {
 378     }
 379   };
 380 }
 381
 382
 383 void SWIG_CSharpException(int code, const char *msg) {
 384   if (code == SWIG_ValueError) {
 385     SWIG_CSharpExceptionArgumentCodes exception_code = SWIG_CSharpArgumentOutOfRangeException;
 386     SWIG_CSharpSetPendingExceptionArgument(exception_code, msg, 0);
 387   } else {
 388     SWIG_CSharpExceptionCodes exception_code = SWIG_CSharpApplicationException;
 389     switch(code) {
 390     case SWIG_MemoryError:
 391       exception_code = SWIG_CSharpOutOfMemoryException;
 392       break;
 393     case SWIG_IndexError:
 394       exception_code = SWIG_CSharpIndexOutOfRangeException;
 395       break;
 396     case SWIG_DivisionByZero:
 397       exception_code = SWIG_CSharpDivideByZeroException;
 398       break;
 399     case SWIG_IOError:
 400       exception_code = SWIG_CSharpIOException;
 401       break;
 402     case SWIG_OverflowError:
 403       exception_code = SWIG_CSharpOverflowException;
 404       break;
 405     case SWIG_RuntimeError:
 406     case SWIG_TypeError:
 407     case SWIG_SyntaxError:
 408     case SWIG_SystemError:
 409     case SWIG_UnknownError:
 410     default:
 411       exception_code = SWIG_CSharpApplicationException;
 412       break;
 413     }
 414     SWIG_CSharpSetPendingException(exception_code, msg);
 415   }
 416 }
 417
 418
 419 #include <stdexcept>
 420
 421
 422 #define SWIGSTDCALL
 423
 424
 425 #include <dali/dali.h>
 426 #include <dali-toolkit/dali-toolkit.h>
 427
 428 #include <dali/devel-api/actors/actor-devel.h>
 429
 430 #include <dali/public-api/math/matrix.h>
 431 #include <dali/public-api/math/matrix3.h>
 432 #include <dali/public-api/math/viewport.h>
 433 #include <dali/public-api/object/property-key.h>
 434 #include <dali/devel-api/object/csharp-type-info.h>
 435 #include <dali/devel-api/object/csharp-type-registry.h>
 436
 437 #include <dali/public-api/adaptor-framework/timer.h>
 438 #include <dali/public-api/adaptor-framework/style-change.h>
 439 #include <dali/devel-api/adaptor-framework/drag-and-drop-detector.h>
 440 #include <dali/devel-api/adaptor-framework/application-extensions.h>
 441
 442 #include <dali/devel-api/images/nine-patch-image.h>
 443
 444 #include <dali-toolkit/devel-api/builder/builder.h>
 445
 446 #include <dali-toolkit/devel-api/focus-manager/keyinput-focus-manager.h>
 447 #include <dali-toolkit/devel-api/focus-manager/keyboard-focus-manager-devel.h>
 448
 449 #include <dali-toolkit/devel-api/controls/control-devel.h>
 450 #include <dali-toolkit/devel-api/controls/popup/popup.h>
 451 #include <dali-toolkit/devel-api/controls/gaussian-blur-view/gaussian-blur-view.h>
 452 #include <dali-toolkit/devel-api/controls/page-turn-view/page-factory.h>
 453 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-view.h>
 454 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-landscape-view.h>
 455 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-portrait-view.h>
 456 #include <dali-toolkit/devel-api/controls/buttons/toggle-button.h>
 457
 458 #include <dali-toolkit/devel-api/visual-factory/visual-base.h>
 459 #include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
 460 #include <dali-toolkit/devel-api/visual-factory/transition-data.h>
 461
 462 #include <dali-toolkit/public-api/visuals/visual-properties.h>
 463 #include <dali-toolkit/public-api/visuals/text-visual-properties.h>
 464 #include <dali-toolkit/public-api/visuals/image-visual-properties.h>
 465
 466 #include <dali-toolkit/devel-api/controls/tooltip/tooltip-properties.h>
 467 #include <dali-toolkit/devel-api/visuals/image-visual-properties-devel.h>
 468
 469 #include <dali-toolkit/public-api/controls/scrollable/item-view/item-view-declarations.h>
 470
 471 #include <dali/devel-api/adaptor-framework/pixel-buffer.h>
 472 #include <dali/devel-api/adaptor-framework/image-loading.h>
 473
 474 // add here SWIG version check
 475
 476 #if defined(_MSC_VER)         // Microsoft Visual C++ 6.0
 477 // disable Swig-dependent warnings
 478
 479 // 'identifier1' has C-linkage specified,
 480 // but returns UDT 'identifier2' which is incompatible with C
 481 #pragma warning(disable: 4190)
 482
 483 // 'int' : forcing value to bool 'true' or 'false' (performance warning)
 484 #pragma warning(disable: 4800)
 485
 486 // debug info too long etc etc
 487 #pragma warning(disable: 4786)
 488 #endif
 489
 490
 491 #include <stdexcept>
 492
 493
 494 #include <string>
 495
 496
 497 #include <vector>
 498 #include <algorithm>
 499 #include <stdexcept>
 500
 501
 502 #include <map>
 503 #include <algorithm>
 504 #include <stdexcept>
 505
 506
 507 #include <utility>
 508
 509
 510 typedef float floatp;
 511
 512 SWIGINTERN floatp *new_floatp(){
 513   return new float();
 514 }
 515 SWIGINTERN void delete_floatp(floatp *self){
 516   if (self) delete self;
 517 }
 518 SWIGINTERN void floatp_assign(floatp *self,float value){
 519   *self = value;
 520 }
 521 SWIGINTERN float floatp_value(floatp *self){
 522   return *self;
 523 }
 524 SWIGINTERN float *floatp_cast(floatp *self){
 525   return self;
 526 }
 527 SWIGINTERN floatp *floatp_frompointer(float *t){
 528   return (floatp *) t;
 529 }
 530
 531 typedef int intp;
 532
 533 SWIGINTERN intp *new_intp(){
 534   return new int();
 535 }
 536 SWIGINTERN void delete_intp(intp *self){
 537   if (self) delete self;
 538 }
 539 SWIGINTERN void intp_assign(intp *self,int value){
 540   *self = value;
 541 }
 542 SWIGINTERN int intp_value(intp *self){
 543   return *self;
 544 }
 545 SWIGINTERN int *intp_cast(intp *self){
 546   return self;
 547 }
 548 SWIGINTERN intp *intp_frompointer(int *t){
 549   return (intp *) t;
 550 }
 551
 552 typedef double doublep;
 553
 554 SWIGINTERN doublep *new_doublep(){
 555   return new double();
 556 }
 557 SWIGINTERN void delete_doublep(doublep *self){
 558   if (self) delete self;
 559 }
 560 SWIGINTERN void doublep_assign(doublep *self,double value){
 561   *self = value;
 562 }
 563 SWIGINTERN double doublep_value(doublep *self){
 564   return *self;
 565 }
 566 SWIGINTERN double *doublep_cast(doublep *self){
 567   return self;
 568 }
 569 SWIGINTERN doublep *doublep_frompointer(double *t){
 570   return (doublep *) t;
 571 }
 572
 573 typedef unsigned int uintp;
 574
 575 SWIGINTERN uintp *new_uintp(){
 576   return new unsigned int();
 577 }
 578 SWIGINTERN void delete_uintp(uintp *self){
 579   if (self) delete self;
 580 }
 581 SWIGINTERN void uintp_assign(uintp *self,unsigned int value){
 582   *self = value;
 583 }
 584 SWIGINTERN unsigned int uintp_value(uintp *self){
 585   return *self;
 586 }
 587 SWIGINTERN unsigned int *uintp_cast(uintp *self){
 588   return self;
 589 }
 590 SWIGINTERN uintp *uintp_frompointer(unsigned int *t){
 591   return (uintp *) t;
 592 }
 593
 594 typedef unsigned short ushortp;
 595
 596 SWIGINTERN ushortp *new_ushortp(){
 597   return new unsigned short();
 598 }
 599 SWIGINTERN void delete_ushortp(ushortp *self){
 600   if (self) delete self;
 601 }
 602 SWIGINTERN void ushortp_assign(ushortp *self,unsigned short value){
 603   *self = value;
 604 }
 605 SWIGINTERN unsigned short ushortp_value(ushortp *self){
 606   return *self;
 607 }
 608 SWIGINTERN unsigned short *ushortp_cast(ushortp *self){
 609   return self;
 610 }
 611 SWIGINTERN ushortp *ushortp_frompointer(unsigned short *t){
 612   return (ushortp *) t;
 613 }
 614
 615 unsigned int int_to_uint(int x) {
 616    return (unsigned int) x;
 617 }
 618
 619
 620 using namespace Dali;
 621 using namespace Dali::Toolkit;
 622
 623 SWIGINTERN bool Dali_BaseHandle_HasBody(Dali::BaseHandle const *self)
 624 {
 625   bool result = false;
 626   try
 627   {
 628     // C++ code. DALi uses Handle <-> Body design pattern.
 629     // This function checks the Handle to see if it has a body attached ( possible to have empty handles).
 630     // Handles in DALi can be converted into a boolean type
 631     // to check if the handle has a valid body attached to it.
 632     // Internally checking *self will  checks IntrusivePtr<Dali::RefObject> mObjectHandle in BaseHandle;
 633     if( *self )
 634     {
 635       result = true;
 636     }
 637     else
 638     {
 639       result = false;
 640     }
 641   }
 642   catch (std::out_of_range& e)
 643   {
 644     SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
 645     return 0;
 646   }
 647   catch (std::exception& e)
 648   {
 649     SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
 650     return 0;
 651   }
 652   catch (DaliException e)
 653   {
 654     SWIG_CSharpException(SWIG_UnknownError, e.condition);
 655     return 0;
 656   }
 657   catch (...)
 658   {
 659     SWIG_CSharpException(SWIG_UnknownError, "unknown error");
 660     return 0;
 661   }
 662   return result;
 663 }
 664
 665 SWIGINTERN bool Dali_BaseHandle_IsEqual(Dali::BaseHandle const *self,Dali::BaseHandle const &rhs)
 666 {
 667   bool result = false;
 668   try
 669   {
 670     // C++ code. Check if two handles reference the same implemtion
 671     if( *self == rhs)
 672     {
 673       result = true;
 674     }
 675     else
 676     {
 677       result = false;
 678     }
 679   }
 680   catch (std::out_of_range& e)
 681   {
 682     SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
 683     return 0;
 684   }
 685   catch (std::exception& e)
 686   {
 687     SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
 688     return 0;
 689   }
 690   catch (DaliException e)
 691   {
 692     SWIG_CSharpException(SWIG_UnknownError, e.condition);
 693     return 0;
 694   }
 695   catch (...)
 696   {
 697     SWIG_CSharpException(SWIG_UnknownError, "unknown error");
 698     return 0;
 699   }
 700   return result;
 701 }
 702
 703
 704 SWIGINTERN void Dali_TypeRegistration_RegisterControl(std::string const &controlName,Dali::CSharpTypeInfo::CreateFunction createFunc){
 705      Dali::CSharpTypeRegistry::RegisterType( controlName, typeid( Dali::Toolkit::Control), createFunc );
 706    }
 707 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){
 708      Dali::CSharpTypeRegistry::RegisterProperty( controlName, propertyName, index, type, setFunc, getFunc );
 709    }
 710 SWIGINTERN std::vector< Dali::TouchPoint > *new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(int capacity){
 711         std::vector< Dali::TouchPoint >* pv = 0;
 712         if (capacity >= 0) {
 713           pv = new std::vector< Dali::TouchPoint >();
 714           pv->reserve(capacity);
 715        } else {
 716           throw std::out_of_range("capacity");
 717        }
 718        return pv;
 719       }
 720 SWIGINTERN Dali::TouchPoint std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(std::vector< Dali::TouchPoint > *self,int index){
 721         if (index>=0 && index<(int)self->size())
 722           return (*self)[index];
 723         else
 724           throw std::out_of_range("index");
 725       }
 726 SWIGINTERN Dali::TouchPoint const &std_vector_Sl_Dali_TouchPoint_Sg__getitem(std::vector< Dali::TouchPoint > *self,int index){
 727         if (index>=0 && index<(int)self->size())
 728           return (*self)[index];
 729         else
 730           throw std::out_of_range("index");
 731       }
 732 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__setitem(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &val){
 733         if (index>=0 && index<(int)self->size())
 734           (*self)[index] = val;
 735         else
 736           throw std::out_of_range("index");
 737       }
 738 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__AddRange(std::vector< Dali::TouchPoint > *self,std::vector< Dali::TouchPoint > const &values){
 739         self->insert(self->end(), values.begin(), values.end());
 740       }
 741 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__GetRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 742         if (index < 0)
 743           throw std::out_of_range("index");
 744         if (count < 0)
 745           throw std::out_of_range("count");
 746         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 747           throw std::invalid_argument("invalid range");
 748         return new std::vector< Dali::TouchPoint >(self->begin()+index, self->begin()+index+count);
 749       }
 750 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Insert(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &x){
 751         if (index>=0 && index<(int)self->size()+1)
 752           self->insert(self->begin()+index, x);
 753         else
 754           throw std::out_of_range("index");
 755       }
 756 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 757         if (index>=0 && index<(int)self->size()+1)
 758           self->insert(self->begin()+index, values.begin(), values.end());
 759         else
 760           throw std::out_of_range("index");
 761       }
 762 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(std::vector< Dali::TouchPoint > *self,int index){
 763         if (index>=0 && index<(int)self->size())
 764           self->erase(self->begin() + index);
 765         else
 766           throw std::out_of_range("index");
 767       }
 768 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 769         if (index < 0)
 770           throw std::out_of_range("index");
 771         if (count < 0)
 772           throw std::out_of_range("count");
 773         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 774           throw std::invalid_argument("invalid range");
 775         self->erase(self->begin()+index, self->begin()+index+count);
 776       }
 777 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__Repeat(Dali::TouchPoint const &value,int count){
 778         if (count < 0)
 779           throw std::out_of_range("count");
 780         return new std::vector< Dali::TouchPoint >(count, value);
 781       }
 782 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(std::vector< Dali::TouchPoint > *self){
 783         std::reverse(self->begin(), self->end());
 784       }
 785 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(std::vector< Dali::TouchPoint > *self,int index,int count){
 786         if (index < 0)
 787           throw std::out_of_range("index");
 788         if (count < 0)
 789           throw std::out_of_range("count");
 790         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 791           throw std::invalid_argument("invalid range");
 792         std::reverse(self->begin()+index, self->begin()+index+count);
 793       }
 794 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__SetRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 795         if (index < 0)
 796           throw std::out_of_range("index");
 797         if (index+values.size() > self->size())
 798           throw std::out_of_range("index");
 799         std::copy(values.begin(), values.end(), self->begin()+index);
 800       }
 801 SWIGINTERN bool Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty(Dali::Signal< void (float) > const *self){
 802          return self->Empty();
 803       }
 804 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount(Dali::Signal< void (float) > const *self){
 805         return self->GetConnectionCount();
 806       }
 807 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(Dali::Signal< void (float) > *self,void (*func)(float)){
 808           self->Connect( func );
 809       }
 810 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(Dali::Signal< void (float) > *self,void (*func)(float)){
 811           self->Disconnect( func );
 812       }
 813 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(Dali::Signal< void (float) > *self,float arg){
 814           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 815 /*@SWIG@*/ self->Emit( arg );
 816       }
 817 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty(Dali::Signal< void (Dali::BaseHandle) > const *self){
 818          return self->Empty();
 819       }
 820 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::BaseHandle) > const *self){
 821         return self->GetConnectionCount();
 822       }
 823 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 824           self->Connect( func );
 825       }
 826 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 827           self->Disconnect( func );
 828       }
 829 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(Dali::Signal< void (Dali::BaseHandle) > *self,Dali::BaseHandle arg){
 830           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 831 /*@SWIG@*/ self->Emit( arg );
 832       }
 833 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty(Dali::Signal< void (Dali::RefObject const *) > const *self){
 834          return self->Empty();
 835       }
 836 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){
 837         return self->GetConnectionCount();
 838       }
 839 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 *)){
 840           self->Connect( func );
 841       }
 842 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 *)){
 843           self->Disconnect( func );
 844       }
 845 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){
 846           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 847 /*@SWIG@*/ self->Emit( arg );
 848       }
 849 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 850          return self->Empty();
 851       }
 852 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 853         return self->GetConnectionCount();
 854       }
 855 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 856           self->Connect( func );
 857       }
 858 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 859           self->Disconnect( func );
 860       }
 861 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(Dali::Signal< void (Dali::PropertyNotification &) > *self,Dali::PropertyNotification &arg){
 862           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 863 /*@SWIG@*/ self->Emit( arg );
 864       }
 865 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty(Dali::Signal< void (Dali::Image) > const *self){
 866          return self->Empty();
 867       }
 868 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Image) > const *self){
 869         return self->GetConnectionCount();
 870       }
 871 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
 872           self->Connect( func );
 873       }
 874 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
 875           self->Disconnect( func );
 876       }
 877 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(Dali::Signal< void (Dali::Image) > *self,Dali::Image arg){
 878           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 879 /*@SWIG@*/ self->Emit( arg );
 880       }
 881 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){
 882          return self->Empty();
 883       }
 884 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){
 885         return self->GetConnectionCount();
 886       }
 887 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 &)){
 888         self->Connect( func );
 889       }
 890 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 &)){
 891         self->Disconnect( func );
 892       }
 893 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){
 894         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 895 /*@SWIG@*/ self->Emit( arg1, arg2 );
 896       }
 897 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){
 898          return self->Empty();
 899       }
 900 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){
 901         return self->GetConnectionCount();
 902       }
 903 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 &)){
 904         self->Connect( func );
 905       }
 906 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 &)){
 907         self->Disconnect( func );
 908       }
 909 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){
 910         return self->Emit( arg1, arg2 );
 911       }
 912 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){
 913          return self->Empty();
 914       }
 915 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){
 916         return self->GetConnectionCount();
 917       }
 918 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 &)){
 919         self->Connect( func );
 920       }
 921 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 &)){
 922         self->Disconnect( func );
 923       }
 924 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){
 925         return self->Emit( arg1, arg2 );
 926       }
 927 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){
 928          return self->Empty();
 929       }
 930 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){
 931         return self->GetConnectionCount();
 932       }
 933 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 &)){
 934         self->Connect( func );
 935       }
 936 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 &)){
 937         self->Disconnect( func );
 938       }
 939 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){
 940         return self->Emit( arg1, arg2 );
 941       }
 942 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor) > const *self){
 943          return self->Empty();
 944       }
 945 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor) > const *self){
 946         return self->GetConnectionCount();
 947       }
 948 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 949           self->Connect( func );
 950       }
 951 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 952           self->Disconnect( func );
 953       }
 954 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(Dali::Signal< void (Dali::Actor) > *self,Dali::Actor arg){
 955           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 956 /*@SWIG@*/ self->Emit( arg );
 957       }
 958 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::KeyEvent const &) > const *self){
 959          return self->Empty();
 960       }
 961 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){
 962         return self->GetConnectionCount();
 963       }
 964 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 &)){
 965           self->Connect( func );
 966       }
 967 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 &)){
 968           self->Disconnect( func );
 969       }
 970 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){
 971           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 972 /*@SWIG@*/ self->Emit( arg );
 973       }
 974 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::TouchData const &) > const *self){
 975          return self->Empty();
 976       }
 977 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){
 978         return self->GetConnectionCount();
 979       }
 980 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 &)){
 981           self->Connect( func );
 982       }
 983 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 &)){
 984           self->Disconnect( func );
 985       }
 986 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){
 987           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 988 /*@SWIG@*/ self->Emit( arg );
 989       }
 990 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::WheelEvent const &) > const *self){
 991          return self->Empty();
 992       }
 993 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){
 994         return self->GetConnectionCount();
 995       }
 996 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 &)){
 997           self->Connect( func );
 998       }
 999 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 &)){
1000           self->Disconnect( func );
1001       }
1002 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){
1003           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1004 /*@SWIG@*/ self->Emit( arg );
1005       }
1006 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){
1007          return self->Empty();
1008       }
1009 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){
1010         return self->GetConnectionCount();
1011       }
1012 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 &)){
1013         self->Connect( func );
1014       }
1015 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 &)){
1016         self->Disconnect( func );
1017       }
1018 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){
1019         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1020 /*@SWIG@*/ self->Emit( arg1, arg2 );
1021       }
1022 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){
1023          return self->Empty();
1024       }
1025 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){
1026         return self->GetConnectionCount();
1027       }
1028 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 &)){
1029         self->Connect( func );
1030       }
1031 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 &)){
1032         self->Disconnect( func );
1033       }
1034 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){
1035         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1036 /*@SWIG@*/ self->Emit( arg1, arg2 );
1037       }
1038 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){
1039          return self->Empty();
1040       }
1041 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){
1042         return self->GetConnectionCount();
1043       }
1044 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 &)){
1045         self->Connect( func );
1046       }
1047 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 &)){
1048         self->Disconnect( func );
1049       }
1050 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){
1051         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1052 /*@SWIG@*/ self->Emit( arg1, arg2 );
1053       }
1054 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty(Dali::Signal< void (Dali::ResourceImage) > const *self){
1055          return self->Empty();
1056       }
1057 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::ResourceImage) > const *self){
1058         return self->GetConnectionCount();
1059       }
1060 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
1061           self->Connect( func );
1062       }
1063 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
1064           self->Disconnect( func );
1065       }
1066 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(Dali::Signal< void (Dali::ResourceImage) > *self,Dali::ResourceImage arg){
1067           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1068 /*@SWIG@*/ self->Emit( arg );
1069       }
1070 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){
1071          return self->Empty();
1072       }
1073 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){
1074         return self->GetConnectionCount();
1075       }
1076 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)){
1077           return self->Connect( func );
1078       }
1079 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)){
1080           self->Disconnect( func );
1081       }
1082 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){
1083           self->Emit( arg1, arg3 );
1084       }
1085 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){
1086          return self->Empty();
1087       }
1088 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){
1089         return self->GetConnectionCount();
1090       }
1091 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)){
1092           return self->Connect( func );
1093       }
1094 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)){
1095           self->Disconnect( func );
1096       }
1097 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){
1098           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1099 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1100       }
1101
1102 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Empty(Dali::Signal< bool () > const *self){
1103          return self->Empty();
1104       }
1105 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount(Dali::Signal< bool () > const *self){
1106         return self->GetConnectionCount();
1107       }
1108 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(Dali::Signal< bool () > *self,bool (*func)()){
1109           self->Connect( func );
1110       }
1111 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(Dali::Signal< bool () > *self,bool (*func)()){
1112           self->Disconnect( func );
1113       }
1114 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(Dali::Signal< bool () > *self){
1115           return self->Emit();
1116       }
1117
1118 SWIGINTERN std::vector< unsigned int > *new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(int capacity){
1119         std::vector< unsigned int >* pv = 0;
1120         if (capacity >= 0) {
1121           pv = new std::vector< unsigned int >();
1122           pv->reserve(capacity);
1123        } else {
1124           throw std::out_of_range("capacity");
1125        }
1126        return pv;
1127       }
1128 SWIGINTERN unsigned int std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(std::vector< unsigned int > *self,int index){
1129         if (index>=0 && index<(int)self->size())
1130           return (*self)[index];
1131         else
1132           throw std::out_of_range("index");
1133       }
1134 SWIGINTERN unsigned int const &std_vector_Sl_unsigned_SS_int_Sg__getitem(std::vector< unsigned int > *self,int index){
1135         if (index>=0 && index<(int)self->size())
1136           return (*self)[index];
1137         else
1138           throw std::out_of_range("index");
1139       }
1140 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__setitem(std::vector< unsigned int > *self,int index,unsigned int const &val){
1141         if (index>=0 && index<(int)self->size())
1142           (*self)[index] = val;
1143         else
1144           throw std::out_of_range("index");
1145       }
1146 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__AddRange(std::vector< unsigned int > *self,std::vector< unsigned int > const &values){
1147         self->insert(self->end(), values.begin(), values.end());
1148       }
1149 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__GetRange(std::vector< unsigned int > *self,int index,int count){
1150         if (index < 0)
1151           throw std::out_of_range("index");
1152         if (count < 0)
1153           throw std::out_of_range("count");
1154         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1155           throw std::invalid_argument("invalid range");
1156         return new std::vector< unsigned int >(self->begin()+index, self->begin()+index+count);
1157       }
1158 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Insert(std::vector< unsigned int > *self,int index,unsigned int const &x){
1159         if (index>=0 && index<(int)self->size()+1)
1160           self->insert(self->begin()+index, x);
1161         else
1162           throw std::out_of_range("index");
1163       }
1164 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__InsertRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1165         if (index>=0 && index<(int)self->size()+1)
1166           self->insert(self->begin()+index, values.begin(), values.end());
1167         else
1168           throw std::out_of_range("index");
1169       }
1170 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(std::vector< unsigned int > *self,int index){
1171         if (index>=0 && index<(int)self->size())
1172           self->erase(self->begin() + index);
1173         else
1174           throw std::out_of_range("index");
1175       }
1176 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(std::vector< unsigned int > *self,int index,int count){
1177         if (index < 0)
1178           throw std::out_of_range("index");
1179         if (count < 0)
1180           throw std::out_of_range("count");
1181         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1182           throw std::invalid_argument("invalid range");
1183         self->erase(self->begin()+index, self->begin()+index+count);
1184       }
1185 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__Repeat(unsigned int const &value,int count){
1186         if (count < 0)
1187           throw std::out_of_range("count");
1188         return new std::vector< unsigned int >(count, value);
1189       }
1190 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(std::vector< unsigned int > *self){
1191         std::reverse(self->begin(), self->end());
1192       }
1193 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(std::vector< unsigned int > *self,int index,int count){
1194         if (index < 0)
1195           throw std::out_of_range("index");
1196         if (count < 0)
1197           throw std::out_of_range("count");
1198         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1199           throw std::invalid_argument("invalid range");
1200         std::reverse(self->begin()+index, self->begin()+index+count);
1201       }
1202 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__SetRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1203         if (index < 0)
1204           throw std::out_of_range("index");
1205         if (index+values.size() > self->size())
1206           throw std::out_of_range("index");
1207         std::copy(values.begin(), values.end(), self->begin()+index);
1208       }
1209 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Contains(std::vector< unsigned int > *self,unsigned int const &value){
1210         return std::find(self->begin(), self->end(), value) != self->end();
1211       }
1212 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__IndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1213         int index = -1;
1214         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1215         if (it != self->end())
1216           index = (int)(it - self->begin());
1217         return index;
1218       }
1219 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1220         int index = -1;
1221         std::vector< unsigned int >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
1222         if (rit != self->rend())
1223           index = (int)(self->rend() - 1 - rit);
1224         return index;
1225       }
1226 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Remove(std::vector< unsigned int > *self,unsigned int const &value){
1227         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1228         if (it != self->end()) {
1229           self->erase(it);
1230           return true;
1231         }
1232         return false;
1233       }
1234 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){
1235         std::vector< std::pair< unsigned int,Dali::Actor > >* pv = 0;
1236         if (capacity >= 0) {
1237           pv = new std::vector< std::pair< unsigned int,Dali::Actor > >();
1238           pv->reserve(capacity);
1239        } else {
1240           throw std::out_of_range("capacity");
1241        }
1242        return pv;
1243       }
1244 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){
1245         if (index>=0 && index<(int)self->size())
1246           return (*self)[index];
1247         else
1248           throw std::out_of_range("index");
1249       }
1250 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){
1251         if (index>=0 && index<(int)self->size())
1252           return (*self)[index];
1253         else
1254           throw std::out_of_range("index");
1255       }
1256 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){
1257         if (index>=0 && index<(int)self->size())
1258           (*self)[index] = val;
1259         else
1260           throw std::out_of_range("index");
1261       }
1262 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){
1263         self->insert(self->end(), values.begin(), values.end());
1264       }
1265 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){
1266         if (index < 0)
1267           throw std::out_of_range("index");
1268         if (count < 0)
1269           throw std::out_of_range("count");
1270         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1271           throw std::invalid_argument("invalid range");
1272         return new std::vector< std::pair< unsigned int,Dali::Actor > >(self->begin()+index, self->begin()+index+count);
1273       }
1274 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){
1275         if (index>=0 && index<(int)self->size()+1)
1276           self->insert(self->begin()+index, x);
1277         else
1278           throw std::out_of_range("index");
1279       }
1280 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){
1281         if (index>=0 && index<(int)self->size()+1)
1282           self->insert(self->begin()+index, values.begin(), values.end());
1283         else
1284           throw std::out_of_range("index");
1285       }
1286 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){
1287         if (index>=0 && index<(int)self->size())
1288           self->erase(self->begin() + index);
1289         else
1290           throw std::out_of_range("index");
1291       }
1292 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){
1293         if (index < 0)
1294           throw std::out_of_range("index");
1295         if (count < 0)
1296           throw std::out_of_range("count");
1297         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1298           throw std::invalid_argument("invalid range");
1299         self->erase(self->begin()+index, self->begin()+index+count);
1300       }
1301 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){
1302         if (count < 0)
1303           throw std::out_of_range("count");
1304         return new std::vector< std::pair< unsigned int,Dali::Actor > >(count, value);
1305       }
1306 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){
1307         std::reverse(self->begin(), self->end());
1308       }
1309 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){
1310         if (index < 0)
1311           throw std::out_of_range("index");
1312         if (count < 0)
1313           throw std::out_of_range("count");
1314         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1315           throw std::invalid_argument("invalid range");
1316         std::reverse(self->begin()+index, self->begin()+index+count);
1317       }
1318 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){
1319         if (index < 0)
1320           throw std::out_of_range("index");
1321         if (index+values.size() > self->size())
1322           throw std::out_of_range("index");
1323         std::copy(values.begin(), values.end(), self->begin()+index);
1324       }
1325 SWIGINTERN std::vector< Dali::Actor > *new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(int capacity){
1326         std::vector< Dali::Actor >* pv = 0;
1327         if (capacity >= 0) {
1328           pv = new std::vector< Dali::Actor >();
1329           pv->reserve(capacity);
1330        } else {
1331           throw std::out_of_range("capacity");
1332        }
1333        return pv;
1334       }
1335 SWIGINTERN Dali::Actor std_vector_Sl_Dali_Actor_Sg__getitemcopy(std::vector< Dali::Actor > *self,int index){
1336         if (index>=0 && index<(int)self->size())
1337           return (*self)[index];
1338         else
1339           throw std::out_of_range("index");
1340       }
1341 SWIGINTERN Dali::Actor const &std_vector_Sl_Dali_Actor_Sg__getitem(std::vector< Dali::Actor > *self,int index){
1342         if (index>=0 && index<(int)self->size())
1343           return (*self)[index];
1344         else
1345           throw std::out_of_range("index");
1346       }
1347 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__setitem(std::vector< Dali::Actor > *self,int index,Dali::Actor const &val){
1348         if (index>=0 && index<(int)self->size())
1349           (*self)[index] = val;
1350         else
1351           throw std::out_of_range("index");
1352       }
1353 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__AddRange(std::vector< Dali::Actor > *self,std::vector< Dali::Actor > const &values){
1354         self->insert(self->end(), values.begin(), values.end());
1355       }
1356 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__GetRange(std::vector< Dali::Actor > *self,int index,int count){
1357         if (index < 0)
1358           throw std::out_of_range("index");
1359         if (count < 0)
1360           throw std::out_of_range("count");
1361         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1362           throw std::invalid_argument("invalid range");
1363         return new std::vector< Dali::Actor >(self->begin()+index, self->begin()+index+count);
1364       }
1365 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Insert(std::vector< Dali::Actor > *self,int index,Dali::Actor const &x){
1366         if (index>=0 && index<(int)self->size()+1)
1367           self->insert(self->begin()+index, x);
1368         else
1369           throw std::out_of_range("index");
1370       }
1371 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__InsertRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1372         if (index>=0 && index<(int)self->size()+1)
1373           self->insert(self->begin()+index, values.begin(), values.end());
1374         else
1375           throw std::out_of_range("index");
1376       }
1377 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveAt(std::vector< Dali::Actor > *self,int index){
1378         if (index>=0 && index<(int)self->size())
1379           self->erase(self->begin() + index);
1380         else
1381           throw std::out_of_range("index");
1382       }
1383 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveRange(std::vector< Dali::Actor > *self,int index,int count){
1384         if (index < 0)
1385           throw std::out_of_range("index");
1386         if (count < 0)
1387           throw std::out_of_range("count");
1388         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1389           throw std::invalid_argument("invalid range");
1390         self->erase(self->begin()+index, self->begin()+index+count);
1391       }
1392 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__Repeat(Dali::Actor const &value,int count){
1393         if (count < 0)
1394           throw std::out_of_range("count");
1395         return new std::vector< Dali::Actor >(count, value);
1396       }
1397 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(std::vector< Dali::Actor > *self){
1398         std::reverse(self->begin(), self->end());
1399       }
1400 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(std::vector< Dali::Actor > *self,int index,int count){
1401         if (index < 0)
1402           throw std::out_of_range("index");
1403         if (count < 0)
1404           throw std::out_of_range("count");
1405         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1406           throw std::invalid_argument("invalid range");
1407         std::reverse(self->begin()+index, self->begin()+index+count);
1408       }
1409 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__SetRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1410         if (index < 0)
1411           throw std::out_of_range("index");
1412         if (index+values.size() > self->size())
1413           throw std::out_of_range("index");
1414         std::copy(values.begin(), values.end(), self->begin()+index);
1415       }
1416 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1417          return self->Empty();
1418       }
1419 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1420         return self->GetConnectionCount();
1421       }
1422 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 &)){
1423           self->Connect( func );
1424       }
1425 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 &)){
1426           self->Disconnect( func );
1427       }
1428 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){
1429           return self->Emit( arg );
1430       }
1431 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){
1432          return self->Empty();
1433       }
1434 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){
1435         return self->GetConnectionCount();
1436       }
1437 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)){
1438         self->Connect( func );
1439       }
1440 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)){
1441         self->Disconnect( func );
1442       }
1443 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){
1444         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1445 /*@SWIG@*/ self->Emit( arg1, arg2 );
1446       }
1447 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::Actor) > const *self){
1448          return self->Empty();
1449       }
1450 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){
1451         return self->GetConnectionCount();
1452       }
1453 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)){
1454         self->Connect( func );
1455       }
1456 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)){
1457         self->Disconnect( func );
1458       }
1459 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){
1460         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1461 /*@SWIG@*/ self->Emit( arg1, arg2 );
1462       }
1463 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,bool) > const *self){
1464          return self->Empty();
1465       }
1466 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,bool) > const *self){
1467         return self->GetConnectionCount();
1468       }
1469 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)){
1470         self->Connect( func );
1471       }
1472 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)){
1473         self->Disconnect( func );
1474       }
1475 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){
1476         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1477 /*@SWIG@*/ self->Emit( arg1, arg2 );
1478       }
1479 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){
1480          return self->Empty();
1481       }
1482 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){
1483         return self->GetConnectionCount();
1484       }
1485 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)){
1486         self->Connect( func );
1487       }
1488 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)){
1489         self->Disconnect( func );
1490       }
1491 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){
1492         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1493 /*@SWIG@*/ self->Emit( arg1, arg2 );
1494       }
1495 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1496          return self->Empty();
1497       }
1498 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1499         return self->GetConnectionCount();
1500       }
1501 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)){
1502           self->Connect( func );
1503       }
1504 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)){
1505           self->Disconnect( func );
1506       }
1507 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Button) > *self,Dali::Toolkit::Button arg){
1508           return self->Emit( arg );
1509       }
1510 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1511          return self->Empty();
1512       }
1513 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1514         return self->GetConnectionCount();
1515       }
1516 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)){
1517           self->Connect( func );
1518       }
1519 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)){
1520           self->Disconnect( func );
1521       }
1522 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,Dali::Toolkit::GaussianBlurView arg){
1523           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1524 /*@SWIG@*/ self->Emit( arg );
1525       }
1526 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){
1527          return self->Empty();
1528       }
1529 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){
1530         return self->GetConnectionCount();
1531       }
1532 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)){
1533           return self->Connect( func );
1534       }
1535 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)){
1536           self->Disconnect( func );
1537       }
1538 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){
1539           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1540 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1541       }
1542 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1543          return self->Empty();
1544       }
1545 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1546         return self->GetConnectionCount();
1547       }
1548 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)){
1549           self->Connect( func );
1550       }
1551 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)){
1552           self->Disconnect( func );
1553       }
1554 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,Dali::Toolkit::PageTurnView arg){
1555           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1556 /*@SWIG@*/ self->Emit( arg );
1557       }
1558 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){
1559          return self->Empty();
1560       }
1561 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){
1562         return self->GetConnectionCount();
1563       }
1564 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)){
1565           return self->Connect( func );
1566       }
1567 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)){
1568           self->Disconnect( func );
1569       }
1570 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){
1571           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1572 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1573       }
1574 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){
1575          return self->Empty();
1576       }
1577 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){
1578         return self->GetConnectionCount();
1579       }
1580 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 &)){
1581           self->Connect( func );
1582       }
1583 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 &)){
1584           self->Disconnect( func );
1585       }
1586 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){
1587           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1588 /*@SWIG@*/ self->Emit( arg );
1589       }
1590 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Vector2 const &) > const *self){
1591          return self->Empty();
1592       }
1593 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){
1594         return self->GetConnectionCount();
1595       }
1596 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 &)){
1597           self->Connect( func );
1598       }
1599 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 &)){
1600           self->Disconnect( func );
1601       }
1602 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){
1603           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1604 /*@SWIG@*/ self->Emit( arg );
1605       }
1606
1607
1608 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){
1609          return self->Empty();
1610       }
1611 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){
1612         return self->GetConnectionCount();
1613       }
1614 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 &)){
1615         self->Connect( func );
1616       }
1617 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 &)){
1618         self->Disconnect( func );
1619       }
1620 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){
1621         return self->Emit( arg1, arg2 );
1622       }
1623 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1624          return self->Empty();
1625       }
1626 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1627         return self->GetConnectionCount();
1628       }
1629 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)){
1630           self->Connect( func );
1631       }
1632 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)){
1633           self->Disconnect( func );
1634       }
1635 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::Control) > *self,Dali::Toolkit::Control arg){
1636           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1637 /*@SWIG@*/ self->Emit( arg );
1638       }
1639 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1640          return self->Empty();
1641       }
1642 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1643         return self->GetConnectionCount();
1644       }
1645 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 &)){
1646           self->Connect( func );
1647       }
1648 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 &)){
1649           self->Disconnect( func );
1650       }
1651 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){
1652           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1653 /*@SWIG@*/ self->Emit( arg );
1654       }
1655 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *self){
1656          return self->Empty();
1657       }
1658 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){
1659         return self->GetConnectionCount();
1660       }
1661 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)){
1662         self->Connect( func );
1663       }
1664 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)){
1665         self->Disconnect( func );
1666       }
1667 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){
1668         return self->Emit( arg1, arg2 );
1669       }
1670 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *self){
1671          return self->Empty();
1672       }
1673 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){
1674         return self->GetConnectionCount();
1675       }
1676 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)){
1677         self->Connect( func );
1678       }
1679 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)){
1680         self->Disconnect( func );
1681       }
1682 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){
1683         return self->Emit( arg1, arg2 );
1684       }
1685
1686
1687 /* ---------------------------------------------------
1688  * C++ director class methods
1689  * --------------------------------------------------- */
1690
1691 #include "dali_wrap.h"
1692
1693 /*
1694  *  Widget director
1695  */
1696 SwigDirector_WidgetImpl::SwigDirector_WidgetImpl() : Dali::Internal::Adaptor::Widget(), Swig::Director() {
1697   swig_init_callbacks();
1698 }
1699
1700 SwigDirector_WidgetImpl::~SwigDirector_WidgetImpl() {
1701 }
1702
1703 void SwigDirector_WidgetImpl::OnCreate(std::string const &contentInfo, Dali::Window window) {
1704   char * jcontentInfo = 0 ;
1705   void * jwindow  ;
1706
1707   if (!swig_callbackOnCreate) {
1708     Dali::Internal::Adaptor::Widget::OnCreate(contentInfo,window);
1709     return;
1710   } else {
1711     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1712     jwindow = (void *)new Dali::Window((const Dali::Window &)window);
1713     swig_callbackOnCreate(jcontentInfo, jwindow);
1714   }
1715 }
1716
1717 void SwigDirector_WidgetImpl::OnTerminate(std::string const &contentInfo, Dali::Widget::Termination type) {
1718   char * jcontentInfo = 0 ;
1719   int jtype  ;
1720
1721   if (!swig_callbackOnTerminate) {
1722     Dali::Internal::Adaptor::Widget::OnTerminate(contentInfo,type);
1723     return;
1724   } else {
1725     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1726     jtype = (int)type;
1727     swig_callbackOnTerminate(jcontentInfo, jtype);
1728   }
1729 }
1730
1731 void SwigDirector_WidgetImpl::OnPause() {
1732   if (!swig_callbackOnPause) {
1733     Dali::Internal::Adaptor::Widget::OnPause();
1734     return;
1735   } else {
1736     swig_callbackOnPause();
1737   }
1738 }
1739
1740 void SwigDirector_WidgetImpl::OnResume() {
1741   if (!swig_callbackOnResume) {
1742     Dali::Internal::Adaptor::Widget::OnResume();
1743     return;
1744   } else {
1745     swig_callbackOnResume();
1746   }
1747 }
1748
1749 void SwigDirector_WidgetImpl::OnResize(Dali::Window window) {
1750   void * jwindow  ;
1751
1752   if (!swig_callbackOnResize) {
1753     Dali::Internal::Adaptor::Widget::OnResize(window);
1754     return;
1755   } else {
1756     jwindow = (void *)new Dali::Window((const Dali::Window &)window);
1757     swig_callbackOnResize(jwindow);
1758   }
1759 }
1760
1761 void SwigDirector_WidgetImpl::OnUpdate(std::string const &contentInfo, int force) {
1762   char * jcontentInfo = 0 ;
1763   int jforce  ;
1764
1765   if (!swig_callbackOnUpdate) {
1766     Dali::Internal::Adaptor::Widget::OnUpdate(contentInfo,force);
1767     return;
1768   } else {
1769     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1770     jforce = force;
1771     swig_callbackOnUpdate(jcontentInfo, jforce);
1772   }
1773 }
1774
1775 void SwigDirector_WidgetImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
1776   void * jslotObserver = 0 ;
1777   void * jcallback = 0 ;
1778
1779   if (!swig_callbackSignalConnected) {
1780     Dali::Internal::Adaptor::Widget::SignalConnected(slotObserver,callback);
1781     return;
1782   } else {
1783     jslotObserver = (void *) slotObserver;
1784     jcallback = (void *) callback;
1785     swig_callbackSignalConnected(jslotObserver, jcallback);
1786   }
1787 }
1788
1789 void SwigDirector_WidgetImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
1790   void * jslotObserver = 0 ;
1791   void * jcallback = 0 ;
1792
1793   if (!swig_callbackSignalDisconnected) {
1794     Dali::Internal::Adaptor::Widget::SignalDisconnected(slotObserver,callback);
1795     return;
1796   } else {
1797     jslotObserver = (void *) slotObserver;
1798     jcallback = (void *) callback;
1799     swig_callbackSignalDisconnected(jslotObserver, jcallback);
1800   }
1801 }
1802
1803 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) {
1804
1805   swig_callbackOnCreate = callbackOnCreate;
1806   swig_callbackOnTerminate = callbackOnTerminate;
1807   swig_callbackOnPause = callbackOnPause;
1808   swig_callbackOnResume = callbackOnResume;
1809   swig_callbackOnResize = callbackOnResize;
1810   swig_callbackOnUpdate = callbackOnUpdate;
1811   swig_callbackSignalConnected = callbackSignalConnected;
1812   swig_callbackSignalDisconnected = callbackSignalDisconnected;
1813 }
1814
1815 void SwigDirector_WidgetImpl::swig_init_callbacks() {
1816   swig_callbackOnCreate = 0;
1817   swig_callbackOnTerminate = 0;
1818   swig_callbackOnPause = 0;
1819   swig_callbackOnResume = 0;
1820   swig_callbackOnResize = 0;
1821   swig_callbackOnUpdate = 0;
1822   swig_callbackSignalConnected = 0;
1823   swig_callbackSignalDisconnected = 0;
1824 }
1825
1826
1827 SwigDirector_ViewImpl::SwigDirector_ViewImpl(Dali::Toolkit::Internal::Control::ControlBehaviour behaviourFlags) : Dali::Toolkit::Internal::Control(behaviourFlags), Swig::Director() {
1828   swig_init_callbacks();
1829 }
1830
1831 SwigDirector_ViewImpl::~SwigDirector_ViewImpl() {
1832
1833 }
1834
1835
1836 void SwigDirector_ViewImpl::OnStageConnection(int depth) {
1837   int jdepth  ;
1838
1839   if (!swig_callbackOnStageConnection) {
1840     Dali::Toolkit::Internal::Control::OnStageConnection(depth);
1841     return;
1842   } else {
1843     jdepth = depth;
1844     swig_callbackOnStageConnection(jdepth);
1845   }
1846 }
1847
1848 void SwigDirector_ViewImpl::OnStageDisconnection() {
1849   if (!swig_callbackOnStageDisconnection) {
1850     Dali::Toolkit::Internal::Control::OnStageDisconnection();
1851     return;
1852   } else {
1853     swig_callbackOnStageDisconnection();
1854   }
1855 }
1856
1857 void SwigDirector_ViewImpl::OnChildAdd(Dali::Actor &child) {
1858   void * jchild = 0 ;
1859
1860   if (!swig_callbackOnChildAdd) {
1861     Dali::Toolkit::Internal::Control::OnChildAdd(child);
1862     return;
1863   } else {
1864     jchild = (Dali::Actor *) &child;
1865     swig_callbackOnChildAdd(jchild);
1866   }
1867 }
1868
1869 void SwigDirector_ViewImpl::OnChildRemove(Dali::Actor &child) {
1870   void * jchild = 0 ;
1871
1872   if (!swig_callbackOnChildRemove) {
1873     Dali::Toolkit::Internal::Control::OnChildRemove(child);
1874     return;
1875   } else {
1876     jchild = (Dali::Actor *) &child;
1877     swig_callbackOnChildRemove(jchild);
1878   }
1879 }
1880
1881 void SwigDirector_ViewImpl::OnPropertySet(Dali::Property::Index index, Dali::Property::Value propertyValue) {
1882   int jindex  ;
1883   void * jpropertyValue  ;
1884
1885   if (!swig_callbackOnPropertySet) {
1886     Dali::Toolkit::Internal::Control::OnPropertySet(index,propertyValue);
1887     return;
1888   } else {
1889     jindex = index;
1890     jpropertyValue = (void *)new Dali::Property::Value((const Dali::Property::Value &)propertyValue);
1891     swig_callbackOnPropertySet(jindex, jpropertyValue);
1892   }
1893 }
1894
1895 void SwigDirector_ViewImpl::OnSizeSet(Dali::Vector3 const &targetSize) {
1896   void * jtargetSize = 0 ;
1897
1898   if (!swig_callbackOnSizeSet) {
1899     Dali::Toolkit::Internal::Control::OnSizeSet(targetSize);
1900     return;
1901   } else {
1902     jtargetSize = (Dali::Vector3 *) &targetSize;
1903     swig_callbackOnSizeSet(jtargetSize);
1904   }
1905 }
1906
1907 void SwigDirector_ViewImpl::OnSizeAnimation(Dali::Animation &animation, Dali::Vector3 const &targetSize) {
1908   void * janimation = 0 ;
1909   void * jtargetSize = 0 ;
1910
1911   if (!swig_callbackOnSizeAnimation) {
1912     Dali::Toolkit::Internal::Control::OnSizeAnimation(animation,targetSize);
1913     return;
1914   } else {
1915     janimation = (Dali::Animation *) &animation;
1916     jtargetSize = (Dali::Vector3 *) &targetSize;
1917     swig_callbackOnSizeAnimation(janimation, jtargetSize);
1918   }
1919 }
1920
1921 bool SwigDirector_ViewImpl::OnTouchEvent(Dali::TouchEvent const &event) {
1922   bool c_result = SwigValueInit< bool >() ;
1923   unsigned int jresult = 0 ;
1924   void * jarg0 = 0 ;
1925
1926   if (!swig_callbackOnTouchEvent) {
1927     return Dali::Toolkit::Internal::Control::OnTouchEvent(event);
1928   } else {
1929     jarg0 = (Dali::TouchEvent *) &event;
1930     jresult = (unsigned int) swig_callbackOnTouchEvent(jarg0);
1931     c_result = jresult ? true : false;
1932   }
1933   return c_result;
1934 }
1935
1936 bool SwigDirector_ViewImpl::OnHoverEvent(Dali::HoverEvent const &event) {
1937   bool c_result = SwigValueInit< bool >() ;
1938   unsigned int jresult = 0 ;
1939   void * jarg0 = 0 ;
1940
1941   if (!swig_callbackOnHoverEvent) {
1942     return Dali::Toolkit::Internal::Control::OnHoverEvent(event);
1943   } else {
1944     jarg0 = (Dali::HoverEvent *) &event;
1945     jresult = (unsigned int) swig_callbackOnHoverEvent(jarg0);
1946     c_result = jresult ? true : false;
1947   }
1948   return c_result;
1949 }
1950
1951 bool SwigDirector_ViewImpl::OnKeyEvent(Dali::KeyEvent const &event) {
1952   bool c_result = SwigValueInit< bool >() ;
1953   unsigned int jresult = 0 ;
1954   void * jarg0 = 0 ;
1955
1956   if (!swig_callbackOnKeyEvent) {
1957     return Dali::Toolkit::Internal::Control::OnKeyEvent(event);
1958   } else {
1959     jarg0 = (Dali::KeyEvent *) &event;
1960     jresult = (unsigned int) swig_callbackOnKeyEvent(jarg0);
1961     c_result = jresult ? true : false;
1962   }
1963   return c_result;
1964 }
1965
1966 bool SwigDirector_ViewImpl::OnWheelEvent(Dali::WheelEvent const &event) {
1967   bool c_result = SwigValueInit< bool >() ;
1968   unsigned int jresult = 0 ;
1969   void * jarg0 = 0 ;
1970
1971   if (!swig_callbackOnWheelEvent) {
1972     return Dali::Toolkit::Internal::Control::OnWheelEvent(event);
1973   } else {
1974     jarg0 = (Dali::WheelEvent *) &event;
1975     jresult = (unsigned int) swig_callbackOnWheelEvent(jarg0);
1976     c_result = jresult ? true : false;
1977   }
1978   return c_result;
1979 }
1980
1981 void SwigDirector_ViewImpl::OnRelayout(Dali::Vector2 const &size, Dali::RelayoutContainer &container) {
1982   void * jsize = 0 ;
1983   void * jcontainer = 0 ;
1984
1985   if (!swig_callbackOnRelayout) {
1986     Dali::Toolkit::Internal::Control::OnRelayout(size,container);
1987     return;
1988   } else {
1989     jsize = (Dali::Vector2 *) &size;
1990     jcontainer = (Dali::RelayoutContainer *) &container;
1991     swig_callbackOnRelayout(jsize, jcontainer);
1992   }
1993 }
1994
1995 void SwigDirector_ViewImpl::OnSetResizePolicy(Dali::ResizePolicy::Type policy, Dali::Dimension::Type dimension) {
1996   int jpolicy  ;
1997   int jdimension  ;
1998
1999   if (!swig_callbackOnSetResizePolicy) {
2000     Dali::Toolkit::Internal::Control::OnSetResizePolicy(policy,dimension);
2001     return;
2002   } else {
2003     jpolicy = (int)policy;
2004     jdimension = (int)dimension;
2005     swig_callbackOnSetResizePolicy(jpolicy, jdimension);
2006   }
2007 }
2008
2009 Dali::Vector3 SwigDirector_ViewImpl::GetNaturalSize() {
2010   Dali::Vector3 c_result ;
2011   void * jresult = 0 ;
2012
2013   if (!swig_callbackGetNaturalSize) {
2014     return Dali::Toolkit::Internal::Control::GetNaturalSize();
2015   } else {
2016     jresult = (void *) swig_callbackGetNaturalSize();
2017     if (!jresult) {
2018       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Vector3", 0);
2019       return c_result;
2020     }
2021     c_result = *(Dali::Vector3 *)jresult;
2022   }
2023   return c_result;
2024 }
2025
2026 float SwigDirector_ViewImpl::CalculateChildSize(Dali::Actor const &child, Dali::Dimension::Type dimension) {
2027   float c_result = SwigValueInit< float >() ;
2028   float jresult = 0 ;
2029   void * jchild = 0 ;
2030   int jdimension  ;
2031
2032   if (!swig_callbackCalculateChildSize) {
2033     return Dali::Toolkit::Internal::Control::CalculateChildSize(child,dimension);
2034   } else {
2035     jchild = (Dali::Actor *) &child;
2036     jdimension = (int)dimension;
2037     jresult = (float) swig_callbackCalculateChildSize(jchild, jdimension);
2038     c_result = (float)jresult;
2039   }
2040   return c_result;
2041 }
2042
2043 float SwigDirector_ViewImpl::GetHeightForWidth(float width) {
2044   float c_result = SwigValueInit< float >() ;
2045   float jresult = 0 ;
2046   float jwidth  ;
2047
2048   if (!swig_callbackGetHeightForWidth) {
2049     return Dali::Toolkit::Internal::Control::GetHeightForWidth(width);
2050   } else {
2051     jwidth = width;
2052     jresult = (float) swig_callbackGetHeightForWidth(jwidth);
2053     c_result = (float)jresult;
2054   }
2055   return c_result;
2056 }
2057
2058 float SwigDirector_ViewImpl::GetWidthForHeight(float height) {
2059   float c_result = SwigValueInit< float >() ;
2060   float jresult = 0 ;
2061   float jheight  ;
2062
2063   if (!swig_callbackGetWidthForHeight) {
2064     return Dali::Toolkit::Internal::Control::GetWidthForHeight(height);
2065   } else {
2066     jheight = height;
2067     jresult = (float) swig_callbackGetWidthForHeight(jheight);
2068     c_result = (float)jresult;
2069   }
2070   return c_result;
2071 }
2072
2073 bool SwigDirector_ViewImpl::RelayoutDependentOnChildren(Dali::Dimension::Type dimension) {
2074   bool c_result = SwigValueInit< bool >() ;
2075   unsigned int jresult = 0 ;
2076   int jdimension  ;
2077
2078   if (!swig_callbackRelayoutDependentOnChildren__SWIG_0) {
2079     return Dali::Toolkit::Internal::Control::RelayoutDependentOnChildren(dimension);
2080   } else {
2081     jdimension = (int)dimension;
2082     jresult = (unsigned int) swig_callbackRelayoutDependentOnChildren__SWIG_0(jdimension);
2083     c_result = jresult ? true : false;
2084   }
2085   return c_result;
2086 }
2087
2088 void SwigDirector_ViewImpl::OnCalculateRelayoutSize(Dali::Dimension::Type dimension) {
2089   int jdimension  ;
2090
2091   if (!swig_callbackOnCalculateRelayoutSize) {
2092     Dali::Toolkit::Internal::Control::OnCalculateRelayoutSize(dimension);
2093     return;
2094   } else {
2095     jdimension = (int)dimension;
2096     swig_callbackOnCalculateRelayoutSize(jdimension);
2097   }
2098 }
2099
2100 void SwigDirector_ViewImpl::OnLayoutNegotiated(float size, Dali::Dimension::Type dimension) {
2101   float jsize  ;
2102   int jdimension  ;
2103
2104   if (!swig_callbackOnLayoutNegotiated) {
2105     Dali::Toolkit::Internal::Control::OnLayoutNegotiated(size,dimension);
2106     return;
2107   } else {
2108     jsize = size;
2109     jdimension = (int)dimension;
2110     swig_callbackOnLayoutNegotiated(jsize, jdimension);
2111   }
2112 }
2113
2114 Dali::CustomActorImpl::Extension *SwigDirector_ViewImpl::GetExtension() {
2115   return Dali::CustomActorImpl::GetExtension();
2116 }
2117
2118 void SwigDirector_ViewImpl::OnInitialize() {
2119   if (!swig_callbackOnInitialize) {
2120     Dali::Toolkit::Internal::Control::OnInitialize();
2121     return;
2122   } else {
2123     swig_callbackOnInitialize();
2124   }
2125 }
2126
2127 void SwigDirector_ViewImpl::OnControlChildAdd(Dali::Actor &child) {
2128   void * jchild = 0 ;
2129
2130   if (!swig_callbackOnControlChildAdd) {
2131     Dali::Toolkit::Internal::Control::OnControlChildAdd(child);
2132     return;
2133   } else {
2134     jchild = (Dali::Actor *) &child;
2135     swig_callbackOnControlChildAdd(jchild);
2136   }
2137 }
2138
2139 void SwigDirector_ViewImpl::OnControlChildRemove(Dali::Actor &child) {
2140   void * jchild = 0 ;
2141
2142   if (!swig_callbackOnControlChildRemove) {
2143     Dali::Toolkit::Internal::Control::OnControlChildRemove(child);
2144     return;
2145   } else {
2146     jchild = (Dali::Actor *) &child;
2147     swig_callbackOnControlChildRemove(jchild);
2148   }
2149 }
2150
2151 void SwigDirector_ViewImpl::OnStyleChange(Dali::Toolkit::StyleManager styleManager, Dali::StyleChange::Type change) {
2152   void * jstyleManager  ;
2153   int jchange  ;
2154
2155   if (!swig_callbackOnStyleChange) {
2156     Dali::Toolkit::Internal::Control::OnStyleChange(styleManager,change);
2157     return;
2158   } else {
2159     jstyleManager = (void *)new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)styleManager);
2160     jchange = (int)change;
2161     swig_callbackOnStyleChange(jstyleManager, jchange);
2162   }
2163 }
2164
2165 bool SwigDirector_ViewImpl::OnAccessibilityActivated() {
2166   bool c_result = SwigValueInit< bool >() ;
2167   unsigned int jresult = 0 ;
2168
2169   if (!swig_callbackOnAccessibilityActivated) {
2170     return Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
2171   } else {
2172     jresult = (unsigned int) swig_callbackOnAccessibilityActivated();
2173     c_result = jresult ? true : false;
2174   }
2175   return c_result;
2176 }
2177
2178 bool SwigDirector_ViewImpl::OnAccessibilityPan(Dali::PanGesture gesture) {
2179   bool c_result = SwigValueInit< bool >() ;
2180   unsigned int jresult = 0 ;
2181   void * jgesture  ;
2182
2183   if (!swig_callbackOnAccessibilityPan) {
2184     return Dali::Toolkit::Internal::Control::OnAccessibilityPan(gesture);
2185   } else {
2186     jgesture = (void *)new Dali::PanGesture((const Dali::PanGesture &)gesture);
2187     jresult = (unsigned int) swig_callbackOnAccessibilityPan(jgesture);
2188     c_result = jresult ? true : false;
2189   }
2190   return c_result;
2191 }
2192
2193 bool SwigDirector_ViewImpl::OnAccessibilityTouch(Dali::TouchEvent const &touchEvent) {
2194   bool c_result = SwigValueInit< bool >() ;
2195   unsigned int jresult = 0 ;
2196   void * jtouchEvent = 0 ;
2197
2198   if (!swig_callbackOnAccessibilityTouch) {
2199     return Dali::Toolkit::Internal::Control::OnAccessibilityTouch(touchEvent);
2200   } else {
2201     jtouchEvent = (Dali::TouchEvent *) &touchEvent;
2202     jresult = (unsigned int) swig_callbackOnAccessibilityTouch(jtouchEvent);
2203     c_result = jresult ? true : false;
2204   }
2205   return c_result;
2206 }
2207
2208 bool SwigDirector_ViewImpl::OnAccessibilityValueChange(bool isIncrease) {
2209   bool c_result = SwigValueInit< bool >() ;
2210   unsigned int jresult = 0 ;
2211   unsigned int jisIncrease  ;
2212
2213   if (!swig_callbackOnAccessibilityValueChange) {
2214     return Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(isIncrease);
2215   } else {
2216     jisIncrease = isIncrease;
2217     jresult = (unsigned int) swig_callbackOnAccessibilityValueChange(jisIncrease);
2218     c_result = jresult ? true : false;
2219   }
2220   return c_result;
2221 }
2222
2223 bool SwigDirector_ViewImpl::OnAccessibilityZoom() {
2224   bool c_result = SwigValueInit< bool >() ;
2225   unsigned int jresult = 0 ;
2226
2227   if (!swig_callbackOnAccessibilityZoom) {
2228     return Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
2229   } else {
2230     jresult = (unsigned int) swig_callbackOnAccessibilityZoom();
2231     c_result = jresult ? true : false;
2232   }
2233   return c_result;
2234 }
2235
2236 void SwigDirector_ViewImpl::OnKeyInputFocusGained() {
2237   if (!swig_callbackOnKeyInputFocusGained) {
2238     Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
2239     return;
2240   } else {
2241     swig_callbackOnKeyInputFocusGained();
2242   }
2243 }
2244
2245 void SwigDirector_ViewImpl::OnKeyInputFocusLost() {
2246   if (!swig_callbackOnKeyInputFocusLost) {
2247     Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
2248     return;
2249   } else {
2250     swig_callbackOnKeyInputFocusLost();
2251   }
2252 }
2253
2254 Dali::Actor SwigDirector_ViewImpl::GetNextKeyboardFocusableActor(Dali::Actor currentFocusedActor, Dali::Toolkit::Control::KeyboardFocus::Direction direction, bool loopEnabled) {
2255   Dali::Actor c_result ;
2256   void * jresult = 0 ;
2257   void * jcurrentFocusedActor  ;
2258   int jdirection  ;
2259   unsigned int jloopEnabled  ;
2260
2261   if (!swig_callbackGetNextKeyboardFocusableActor) {
2262     return Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(currentFocusedActor,direction,loopEnabled);
2263   } else {
2264     jcurrentFocusedActor = (void *)new Dali::Actor((const Dali::Actor &)currentFocusedActor);
2265     jdirection = (int)direction;
2266     jloopEnabled = loopEnabled;
2267     jresult = (void *) swig_callbackGetNextKeyboardFocusableActor(jcurrentFocusedActor, jdirection, jloopEnabled);
2268     if (!jresult) {
2269       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2270       return c_result;
2271     }
2272     c_result = *(Dali::Actor *)jresult;
2273   }
2274   return c_result;
2275 }
2276
2277 void SwigDirector_ViewImpl::OnKeyboardFocusChangeCommitted(Dali::Actor commitedFocusableActor) {
2278   void * jcommitedFocusableActor  ;
2279
2280   if (!swig_callbackOnKeyboardFocusChangeCommitted) {
2281     Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(commitedFocusableActor);
2282     return;
2283   } else {
2284     jcommitedFocusableActor = (void *)new Dali::Actor((const Dali::Actor &)commitedFocusableActor);
2285     swig_callbackOnKeyboardFocusChangeCommitted(jcommitedFocusableActor);
2286   }
2287 }
2288
2289 bool SwigDirector_ViewImpl::OnKeyboardEnter() {
2290   bool c_result = SwigValueInit< bool >() ;
2291   unsigned int jresult = 0 ;
2292
2293   if (!swig_callbackOnKeyboardEnter) {
2294     return Dali::Toolkit::Internal::Control::OnKeyboardEnter();
2295   } else {
2296     jresult = (unsigned int) swig_callbackOnKeyboardEnter();
2297     c_result = jresult ? true : false;
2298   }
2299   return c_result;
2300 }
2301
2302 void SwigDirector_ViewImpl::OnPinch(Dali::PinchGesture const &pinch) {
2303   void * jpinch = 0 ;
2304
2305   if (!swig_callbackOnPinch) {
2306     Dali::Toolkit::Internal::Control::OnPinch(pinch);
2307     return;
2308   } else {
2309     jpinch = (Dali::PinchGesture *) &pinch;
2310     swig_callbackOnPinch(jpinch);
2311   }
2312 }
2313
2314 void SwigDirector_ViewImpl::OnPan(Dali::PanGesture const &pan) {
2315   void * jpan = 0 ;
2316
2317   if (!swig_callbackOnPan) {
2318     Dali::Toolkit::Internal::Control::OnPan(pan);
2319     return;
2320   } else {
2321     jpan = (Dali::PanGesture *) &pan;
2322     swig_callbackOnPan(jpan);
2323   }
2324 }
2325
2326 void SwigDirector_ViewImpl::OnTap(Dali::TapGesture const &tap) {
2327   void * jtap = 0 ;
2328
2329   if (!swig_callbackOnTap) {
2330     Dali::Toolkit::Internal::Control::OnTap(tap);
2331     return;
2332   } else {
2333     jtap = (Dali::TapGesture *) &tap;
2334     swig_callbackOnTap(jtap);
2335   }
2336 }
2337
2338 void SwigDirector_ViewImpl::OnLongPress(Dali::LongPressGesture const &longPress) {
2339   void * jlongPress = 0 ;
2340
2341   if (!swig_callbackOnLongPress) {
2342     Dali::Toolkit::Internal::Control::OnLongPress(longPress);
2343     return;
2344   } else {
2345     jlongPress = (Dali::LongPressGesture *) &longPress;
2346     swig_callbackOnLongPress(jlongPress);
2347   }
2348 }
2349
2350 void SwigDirector_ViewImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2351   void * jslotObserver = 0 ;
2352   void * jcallback = 0 ;
2353
2354   if (!swig_callbackSignalConnected) {
2355     Dali::Toolkit::Internal::Control::SignalConnected(slotObserver,callback);
2356     return;
2357   } else {
2358     jslotObserver = (void *) slotObserver;
2359     jcallback = (void *) callback;
2360     swig_callbackSignalConnected(jslotObserver, jcallback);
2361   }
2362 }
2363
2364 void SwigDirector_ViewImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2365   void * jslotObserver = 0 ;
2366   void * jcallback = 0 ;
2367
2368   if (!swig_callbackSignalDisconnected) {
2369     Dali::Toolkit::Internal::Control::SignalDisconnected(slotObserver,callback);
2370     return;
2371   } else {
2372     jslotObserver = (void *) slotObserver;
2373     jcallback = (void *) callback;
2374     swig_callbackSignalDisconnected(jslotObserver, jcallback);
2375   }
2376 }
2377
2378 Dali::Toolkit::Internal::Control::Extension *SwigDirector_ViewImpl::GetControlExtension() {
2379   return Dali::Toolkit::Internal::Control::GetControlExtension();
2380 }
2381
2382 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) {
2383   swig_callbackOnStageConnection = callbackOnStageConnection;
2384   swig_callbackOnStageDisconnection = callbackOnStageDisconnection;
2385   swig_callbackOnChildAdd = callbackOnChildAdd;
2386   swig_callbackOnChildRemove = callbackOnChildRemove;
2387   swig_callbackOnPropertySet = callbackOnPropertySet;
2388   swig_callbackOnSizeSet = callbackOnSizeSet;
2389   swig_callbackOnSizeAnimation = callbackOnSizeAnimation;
2390   swig_callbackOnTouchEvent = callbackOnTouchEvent;
2391   swig_callbackOnHoverEvent = callbackOnHoverEvent;
2392   swig_callbackOnKeyEvent = callbackOnKeyEvent;
2393   swig_callbackOnWheelEvent = callbackOnWheelEvent;
2394   swig_callbackOnRelayout = callbackOnRelayout;
2395   swig_callbackOnSetResizePolicy = callbackOnSetResizePolicy;
2396   swig_callbackGetNaturalSize = callbackGetNaturalSize;
2397   swig_callbackCalculateChildSize = callbackCalculateChildSize;
2398   swig_callbackGetHeightForWidth = callbackGetHeightForWidth;
2399   swig_callbackGetWidthForHeight = callbackGetWidthForHeight;
2400   swig_callbackRelayoutDependentOnChildren__SWIG_0 = callbackRelayoutDependentOnChildren__SWIG_0;
2401   swig_callbackRelayoutDependentOnChildren__SWIG_1 = callbackRelayoutDependentOnChildren__SWIG_1;
2402   swig_callbackOnCalculateRelayoutSize = callbackOnCalculateRelayoutSize;
2403   swig_callbackOnLayoutNegotiated = callbackOnLayoutNegotiated;
2404   swig_callbackOnInitialize = callbackOnInitialize;
2405   swig_callbackOnControlChildAdd = callbackOnControlChildAdd;
2406   swig_callbackOnControlChildRemove = callbackOnControlChildRemove;
2407   swig_callbackOnStyleChange = callbackOnStyleChange;
2408   swig_callbackOnAccessibilityActivated = callbackOnAccessibilityActivated;
2409   swig_callbackOnAccessibilityPan = callbackOnAccessibilityPan;
2410   swig_callbackOnAccessibilityTouch = callbackOnAccessibilityTouch;
2411   swig_callbackOnAccessibilityValueChange = callbackOnAccessibilityValueChange;
2412   swig_callbackOnAccessibilityZoom = callbackOnAccessibilityZoom;
2413   swig_callbackOnKeyInputFocusGained = callbackOnKeyInputFocusGained;
2414   swig_callbackOnKeyInputFocusLost = callbackOnKeyInputFocusLost;
2415   swig_callbackGetNextKeyboardFocusableActor = callbackGetNextKeyboardFocusableActor;
2416   swig_callbackOnKeyboardFocusChangeCommitted = callbackOnKeyboardFocusChangeCommitted;
2417   swig_callbackOnKeyboardEnter = callbackOnKeyboardEnter;
2418   swig_callbackOnPinch = callbackOnPinch;
2419   swig_callbackOnPan = callbackOnPan;
2420   swig_callbackOnTap = callbackOnTap;
2421   swig_callbackOnLongPress = callbackOnLongPress;
2422   swig_callbackSignalConnected = callbackSignalConnected;
2423   swig_callbackSignalDisconnected = callbackSignalDisconnected;
2424 }
2425
2426 void SwigDirector_ViewImpl::swig_init_callbacks() {
2427   swig_callbackOnStageConnection = 0;
2428   swig_callbackOnStageDisconnection = 0;
2429   swig_callbackOnChildAdd = 0;
2430   swig_callbackOnChildRemove = 0;
2431   swig_callbackOnPropertySet = 0;
2432   swig_callbackOnSizeSet = 0;
2433   swig_callbackOnSizeAnimation = 0;
2434   swig_callbackOnTouchEvent = 0;
2435   swig_callbackOnHoverEvent = 0;
2436   swig_callbackOnKeyEvent = 0;
2437   swig_callbackOnWheelEvent = 0;
2438   swig_callbackOnRelayout = 0;
2439   swig_callbackOnSetResizePolicy = 0;
2440   swig_callbackGetNaturalSize = 0;
2441   swig_callbackCalculateChildSize = 0;
2442   swig_callbackGetHeightForWidth = 0;
2443   swig_callbackGetWidthForHeight = 0;
2444   swig_callbackRelayoutDependentOnChildren__SWIG_0 = 0;
2445   swig_callbackRelayoutDependentOnChildren__SWIG_1 = 0;
2446   swig_callbackOnCalculateRelayoutSize = 0;
2447   swig_callbackOnLayoutNegotiated = 0;
2448   swig_callbackOnInitialize = 0;
2449   swig_callbackOnControlChildAdd = 0;
2450   swig_callbackOnControlChildRemove = 0;
2451   swig_callbackOnStyleChange = 0;
2452   swig_callbackOnAccessibilityActivated = 0;
2453   swig_callbackOnAccessibilityPan = 0;
2454   swig_callbackOnAccessibilityTouch = 0;
2455   swig_callbackOnAccessibilityValueChange = 0;
2456   swig_callbackOnAccessibilityZoom = 0;
2457   swig_callbackOnKeyInputFocusGained = 0;
2458   swig_callbackOnKeyInputFocusLost = 0;
2459   swig_callbackGetNextKeyboardFocusableActor = 0;
2460   swig_callbackOnKeyboardFocusChangeCommitted = 0;
2461   swig_callbackOnKeyboardEnter = 0;
2462   swig_callbackOnPinch = 0;
2463   swig_callbackOnPan = 0;
2464   swig_callbackOnTap = 0;
2465   swig_callbackOnLongPress = 0;
2466   swig_callbackSignalConnected = 0;
2467   swig_callbackSignalDisconnected = 0;
2468 }
2469
2470 SwigDirector_ItemFactory::SwigDirector_ItemFactory() : Dali::Toolkit::ItemFactory(), Swig::Director() {
2471   swig_init_callbacks();
2472 }
2473
2474 SwigDirector_ItemFactory::~SwigDirector_ItemFactory() {
2475
2476 }
2477
2478
2479 unsigned int SwigDirector_ItemFactory::GetNumberOfItems() {
2480   unsigned int c_result = SwigValueInit< unsigned int >() ;
2481   unsigned int jresult = 0 ;
2482
2483   if (!swig_callbackGetNumberOfItems) {
2484     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::GetNumberOfItems");
2485   } else {
2486     jresult = (unsigned int) swig_callbackGetNumberOfItems();
2487     c_result = (unsigned int)jresult;
2488   }
2489   return c_result;
2490 }
2491
2492 Dali::Actor SwigDirector_ItemFactory::NewItem(unsigned int itemId) {
2493   Dali::Actor c_result ;
2494   void * jresult = 0 ;
2495   unsigned int jitemId  ;
2496
2497   if (!swig_callbackNewItem) {
2498     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::NewItem");
2499   } else {
2500     jitemId = itemId;
2501     jresult = (void *) swig_callbackNewItem(jitemId);
2502     if (!jresult) {
2503       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2504       return c_result;
2505     }
2506     c_result = *(Dali::Actor *)jresult;
2507   }
2508   return c_result;
2509 }
2510
2511 void SwigDirector_ItemFactory::ItemReleased(unsigned int itemId, Dali::Actor actor) {
2512   unsigned int jitemId  ;
2513   void * jactor  ;
2514
2515   if (!swig_callbackItemReleased) {
2516     Dali::Toolkit::ItemFactory::ItemReleased(itemId,actor);
2517     return;
2518   } else {
2519     jitemId = itemId;
2520     jactor = (void *)new Dali::Actor((const Dali::Actor &)actor);
2521     swig_callbackItemReleased(jitemId, jactor);
2522   }
2523 }
2524
2525 Dali::Toolkit::ItemFactory::Extension *SwigDirector_ItemFactory::GetExtension() {
2526   return Dali::Toolkit::ItemFactory::GetExtension();
2527 }
2528
2529 void SwigDirector_ItemFactory::swig_connect_director(SWIG_Callback0_t callbackGetNumberOfItems, SWIG_Callback1_t callbackNewItem, SWIG_Callback2_t callbackItemReleased) {
2530   swig_callbackGetNumberOfItems = callbackGetNumberOfItems;
2531   swig_callbackNewItem = callbackNewItem;
2532   swig_callbackItemReleased = callbackItemReleased;
2533 }
2534
2535 void SwigDirector_ItemFactory::swig_init_callbacks() {
2536   swig_callbackGetNumberOfItems = 0;
2537   swig_callbackNewItem = 0;
2538   swig_callbackItemReleased = 0;
2539 }
2540
2541 SwigDirector_CustomAlgorithmInterface::SwigDirector_CustomAlgorithmInterface() : Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface(), Swig::Director() {
2542   swig_init_callbacks();
2543 }
2544
2545 SwigDirector_CustomAlgorithmInterface::~SwigDirector_CustomAlgorithmInterface() {
2546
2547 }
2548
2549
2550 Dali::Actor SwigDirector_CustomAlgorithmInterface::GetNextFocusableActor(Dali::Actor current, Dali::Actor proposed, Dali::Toolkit::Control::KeyboardFocus::Direction direction) {
2551   Dali::Actor c_result ;
2552   void * jresult = 0 ;
2553   void * jcurrent  ;
2554   void * jproposed  ;
2555   int jdirection  ;
2556
2557   if (!swig_callbackGetNextFocusableActor) {
2558     throw Swig::DirectorPureVirtualException("Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface::GetNextFocusableActor");
2559   } else {
2560     jcurrent = (void *)new Dali::Actor((const Dali::Actor &)current);
2561     jproposed = (void *)new Dali::Actor((const Dali::Actor &)proposed);
2562     jdirection = (int)direction;
2563     jresult = (void *) swig_callbackGetNextFocusableActor(jcurrent, jproposed, jdirection);
2564     if (!jresult) {
2565       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2566       return c_result;
2567     }
2568     c_result = *(Dali::Actor *)jresult;
2569   }
2570   return c_result;
2571 }
2572
2573 void SwigDirector_CustomAlgorithmInterface::swig_connect_director(SWIG_Callback0_t callbackGetNextFocusableActor) {
2574   swig_callbackGetNextFocusableActor = callbackGetNextFocusableActor;
2575 }
2576
2577 void SwigDirector_CustomAlgorithmInterface::swig_init_callbacks() {
2578   swig_callbackGetNextFocusableActor = 0;
2579 }
2580
2581
2582 #ifdef __cplusplus
2583 extern "C" {
2584 #endif
2585
2586 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_floatp() {
2587   void * jresult ;
2588   floatp *result = 0 ;
2589
2590   {
2591     try {
2592       result = (floatp *)new_floatp();
2593     } catch (std::out_of_range& e) {
2594       {
2595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2596       };
2597     } catch (std::exception& e) {
2598       {
2599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2600       };
2601     } catch (DaliException e) {
2602       {
2603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2604       };
2605     } catch (...) {
2606       {
2607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2608       };
2609     }
2610   }
2611   jresult = (void *)result;
2612   return jresult;
2613 }
2614
2615
2616 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_floatp(void * jarg1) {
2617   floatp *arg1 = (floatp *) 0 ;
2618
2619   arg1 = (floatp *)jarg1;
2620   {
2621     try {
2622       delete_floatp(arg1);
2623     } catch (std::out_of_range& e) {
2624       {
2625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2626       };
2627     } catch (std::exception& e) {
2628       {
2629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2630       };
2631     } catch (Dali::DaliException e) {
2632       {
2633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2634       };
2635     } catch (...) {
2636       {
2637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2638       };
2639     }
2640   }
2641
2642 }
2643
2644
2645 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_floatp_assign(void * jarg1, float jarg2) {
2646   floatp *arg1 = (floatp *) 0 ;
2647   float arg2 ;
2648
2649   arg1 = (floatp *)jarg1;
2650   arg2 = (float)jarg2;
2651   {
2652     try {
2653       floatp_assign(arg1,arg2);
2654     } catch (std::out_of_range& e) {
2655       {
2656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2657       };
2658     } catch (std::exception& e) {
2659       {
2660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2661       };
2662     } catch (Dali::DaliException e) {
2663       {
2664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2665       };
2666     } catch (...) {
2667       {
2668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2669       };
2670     }
2671   }
2672
2673 }
2674
2675
2676 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_floatp_value(void * jarg1) {
2677   float jresult ;
2678   floatp *arg1 = (floatp *) 0 ;
2679   float result;
2680
2681   arg1 = (floatp *)jarg1;
2682   {
2683     try {
2684       result = (float)floatp_value(arg1);
2685     } catch (std::out_of_range& e) {
2686       {
2687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2688       };
2689     } catch (std::exception& e) {
2690       {
2691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2692       };
2693     } catch (DaliException e) {
2694       {
2695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2696       };
2697     } catch (...) {
2698       {
2699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2700       };
2701     }
2702   }
2703   jresult = result;
2704   return jresult;
2705 }
2706
2707
2708 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_cast(void * jarg1) {
2709   void * jresult ;
2710   floatp *arg1 = (floatp *) 0 ;
2711   float *result = 0 ;
2712
2713   arg1 = (floatp *)jarg1;
2714   {
2715     try {
2716       result = (float *)floatp_cast(arg1);
2717     } catch (std::out_of_range& e) {
2718       {
2719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2720       };
2721     } catch (std::exception& e) {
2722       {
2723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2724       };
2725     } catch (Dali::DaliException e) {
2726       {
2727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2728       };
2729     } catch (...) {
2730       {
2731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2732       };
2733     }
2734   }
2735
2736   jresult = (void *)result;
2737   return jresult;
2738 }
2739
2740
2741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_frompointer(void * jarg1) {
2742   void * jresult ;
2743   float *arg1 = (float *) 0 ;
2744   floatp *result = 0 ;
2745
2746   arg1 = (float *)jarg1;
2747   {
2748     try {
2749       result = (floatp *)floatp_frompointer(arg1);
2750     } catch (std::out_of_range& e) {
2751       {
2752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2753       };
2754     } catch (std::exception& e) {
2755       {
2756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2757       };
2758     } catch (Dali::DaliException e) {
2759       {
2760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2761       };
2762     } catch (...) {
2763       {
2764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2765       };
2766     }
2767   }
2768
2769   jresult = (void *)result;
2770   return jresult;
2771 }
2772
2773
2774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_intp() {
2775   void * jresult ;
2776   intp *result = 0 ;
2777
2778   {
2779     try {
2780       result = (intp *)new_intp();
2781     } catch (std::out_of_range& e) {
2782       {
2783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2784       };
2785     } catch (std::exception& e) {
2786       {
2787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2788       };
2789     } catch (Dali::DaliException e) {
2790       {
2791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2792       };
2793     } catch (...) {
2794       {
2795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2796       };
2797     }
2798   }
2799
2800   jresult = (void *)result;
2801   return jresult;
2802 }
2803
2804
2805 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_intp(void * jarg1) {
2806   intp *arg1 = (intp *) 0 ;
2807
2808   arg1 = (intp *)jarg1;
2809   {
2810     try {
2811       delete_intp(arg1);
2812     } catch (std::out_of_range& e) {
2813       {
2814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2815       };
2816     } catch (std::exception& e) {
2817       {
2818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2819       };
2820     } catch (Dali::DaliException e) {
2821       {
2822         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2823       };
2824     } catch (...) {
2825       {
2826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2827       };
2828     }
2829   }
2830
2831 }
2832
2833
2834 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_intp_assign(void * jarg1, int jarg2) {
2835   intp *arg1 = (intp *) 0 ;
2836   int arg2 ;
2837
2838   arg1 = (intp *)jarg1;
2839   arg2 = (int)jarg2;
2840   {
2841     try {
2842       intp_assign(arg1,arg2);
2843     } catch (std::out_of_range& e) {
2844       {
2845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2846       };
2847     } catch (std::exception& e) {
2848       {
2849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2850       };
2851     } catch (Dali::DaliException e) {
2852       {
2853         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2854       };
2855     } catch (...) {
2856       {
2857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2858       };
2859     }
2860   }
2861
2862 }
2863
2864
2865 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_intp_value(void * jarg1) {
2866   int jresult ;
2867   intp *arg1 = (intp *) 0 ;
2868   int result;
2869
2870   arg1 = (intp *)jarg1;
2871   {
2872     try {
2873       result = (int)intp_value(arg1);
2874     } catch (std::out_of_range& e) {
2875       {
2876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2877       };
2878     } catch (std::exception& e) {
2879       {
2880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2881       };
2882     } catch (Dali::DaliException e) {
2883       {
2884         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2885       };
2886     } catch (...) {
2887       {
2888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2889       };
2890     }
2891   }
2892
2893   jresult = result;
2894   return jresult;
2895 }
2896
2897
2898 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_cast(void * jarg1) {
2899   void * jresult ;
2900   intp *arg1 = (intp *) 0 ;
2901   int *result = 0 ;
2902
2903   arg1 = (intp *)jarg1;
2904   {
2905     try {
2906       result = (int *)intp_cast(arg1);
2907     } catch (std::out_of_range& e) {
2908       {
2909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2910       };
2911     } catch (std::exception& e) {
2912       {
2913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2914       };
2915     } catch (Dali::DaliException e) {
2916       {
2917         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2918       };
2919     } catch (...) {
2920       {
2921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2922       };
2923     }
2924   }
2925
2926   jresult = (void *)result;
2927   return jresult;
2928 }
2929
2930
2931 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_frompointer(void * jarg1) {
2932   void * jresult ;
2933   int *arg1 = (int *) 0 ;
2934   intp *result = 0 ;
2935
2936   arg1 = (int *)jarg1;
2937   {
2938     try {
2939       result = (intp *)intp_frompointer(arg1);
2940     } catch (std::out_of_range& e) {
2941       {
2942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2943       };
2944     } catch (std::exception& e) {
2945       {
2946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2947       };
2948     } catch (Dali::DaliException e) {
2949       {
2950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2951       };
2952     } catch (...) {
2953       {
2954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2955       };
2956     }
2957   }
2958
2959   jresult = (void *)result;
2960   return jresult;
2961 }
2962
2963
2964 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_doublep() {
2965   void * jresult ;
2966   doublep *result = 0 ;
2967
2968   {
2969     try {
2970       result = (doublep *)new_doublep();
2971     } catch (std::out_of_range& e) {
2972       {
2973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2974       };
2975     } catch (std::exception& e) {
2976       {
2977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2978       };
2979     } catch (Dali::DaliException e) {
2980       {
2981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2982       };
2983     } catch (...) {
2984       {
2985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2986       };
2987     }
2988   }
2989
2990   jresult = (void *)result;
2991   return jresult;
2992 }
2993
2994
2995 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_doublep(void * jarg1) {
2996   doublep *arg1 = (doublep *) 0 ;
2997
2998   arg1 = (doublep *)jarg1;
2999   {
3000     try {
3001       delete_doublep(arg1);
3002     } catch (std::out_of_range& e) {
3003       {
3004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3005       };
3006     } catch (std::exception& e) {
3007       {
3008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3009       };
3010     } catch (Dali::DaliException e) {
3011       {
3012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3013       };
3014     } catch (...) {
3015       {
3016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3017       };
3018     }
3019   }
3020
3021 }
3022
3023
3024 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_doublep_assign(void * jarg1, double jarg2) {
3025   doublep *arg1 = (doublep *) 0 ;
3026   double arg2 ;
3027
3028   arg1 = (doublep *)jarg1;
3029   arg2 = (double)jarg2;
3030   {
3031     try {
3032       doublep_assign(arg1,arg2);
3033     } catch (std::out_of_range& e) {
3034       {
3035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3036       };
3037     } catch (std::exception& e) {
3038       {
3039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3040       };
3041     } catch (Dali::DaliException e) {
3042       {
3043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3044       };
3045     } catch (...) {
3046       {
3047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3048       };
3049     }
3050   }
3051
3052 }
3053
3054
3055 SWIGEXPORT double SWIGSTDCALL CSharp_Dali_doublep_value(void * jarg1) {
3056   double jresult ;
3057   doublep *arg1 = (doublep *) 0 ;
3058   double result;
3059
3060   arg1 = (doublep *)jarg1;
3061   {
3062     try {
3063       result = (double)doublep_value(arg1);
3064     } catch (std::out_of_range& e) {
3065       {
3066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3067       };
3068     } catch (std::exception& e) {
3069       {
3070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3071       };
3072     } catch (Dali::DaliException e) {
3073       {
3074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3075       };
3076     } catch (...) {
3077       {
3078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3079       };
3080     }
3081   }
3082
3083   jresult = result;
3084   return jresult;
3085 }
3086
3087
3088 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_cast(void * jarg1) {
3089   void * jresult ;
3090   doublep *arg1 = (doublep *) 0 ;
3091   double *result = 0 ;
3092
3093   arg1 = (doublep *)jarg1;
3094   {
3095     try {
3096       result = (double *)doublep_cast(arg1);
3097     } catch (std::out_of_range& e) {
3098       {
3099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3100       };
3101     } catch (std::exception& e) {
3102       {
3103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3104       };
3105     } catch (Dali::DaliException e) {
3106       {
3107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3108       };
3109     } catch (...) {
3110       {
3111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3112       };
3113     }
3114   }
3115
3116   jresult = (void *)result;
3117   return jresult;
3118 }
3119
3120
3121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_frompointer(void * jarg1) {
3122   void * jresult ;
3123   double *arg1 = (double *) 0 ;
3124   doublep *result = 0 ;
3125
3126   arg1 = (double *)jarg1;
3127   {
3128     try {
3129       result = (doublep *)doublep_frompointer(arg1);
3130     } catch (std::out_of_range& e) {
3131       {
3132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3133       };
3134     } catch (std::exception& e) {
3135       {
3136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3137       };
3138     } catch (Dali::DaliException e) {
3139       {
3140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3141       };
3142     } catch (...) {
3143       {
3144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3145       };
3146     }
3147   }
3148
3149   jresult = (void *)result;
3150   return jresult;
3151 }
3152
3153
3154 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_uintp() {
3155   void * jresult ;
3156   uintp *result = 0 ;
3157
3158   {
3159     try {
3160       result = (uintp *)new_uintp();
3161     } catch (std::out_of_range& e) {
3162       {
3163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3164       };
3165     } catch (std::exception& e) {
3166       {
3167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3168       };
3169     } catch (Dali::DaliException e) {
3170       {
3171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3172       };
3173     } catch (...) {
3174       {
3175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3176       };
3177     }
3178   }
3179
3180   jresult = (void *)result;
3181   return jresult;
3182 }
3183
3184
3185 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_uintp(void * jarg1) {
3186   uintp *arg1 = (uintp *) 0 ;
3187
3188   arg1 = (uintp *)jarg1;
3189   {
3190     try {
3191       delete_uintp(arg1);
3192     } catch (std::out_of_range& e) {
3193       {
3194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3195       };
3196     } catch (std::exception& e) {
3197       {
3198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3199       };
3200     } catch (Dali::DaliException e) {
3201       {
3202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3203       };
3204     } catch (...) {
3205       {
3206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3207       };
3208     }
3209   }
3210
3211 }
3212
3213
3214 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_uintp_assign(void * jarg1, unsigned int jarg2) {
3215   uintp *arg1 = (uintp *) 0 ;
3216   unsigned int arg2 ;
3217
3218   arg1 = (uintp *)jarg1;
3219   arg2 = (unsigned int)jarg2;
3220   {
3221     try {
3222       uintp_assign(arg1,arg2);
3223     } catch (std::out_of_range& e) {
3224       {
3225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3226       };
3227     } catch (std::exception& e) {
3228       {
3229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3230       };
3231     } catch (Dali::DaliException e) {
3232       {
3233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3234       };
3235     } catch (...) {
3236       {
3237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3238       };
3239     }
3240   }
3241
3242 }
3243
3244
3245 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_uintp_value(void * jarg1) {
3246   unsigned int jresult ;
3247   uintp *arg1 = (uintp *) 0 ;
3248   unsigned int result;
3249
3250   arg1 = (uintp *)jarg1;
3251   {
3252     try {
3253       result = (unsigned int)uintp_value(arg1);
3254     } catch (std::out_of_range& e) {
3255       {
3256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3257       };
3258     } catch (std::exception& e) {
3259       {
3260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3261       };
3262     } catch (Dali::DaliException e) {
3263       {
3264         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3265       };
3266     } catch (...) {
3267       {
3268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3269       };
3270     }
3271   }
3272
3273   jresult = result;
3274   return jresult;
3275 }
3276
3277
3278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_cast(void * jarg1) {
3279   void * jresult ;
3280   uintp *arg1 = (uintp *) 0 ;
3281   unsigned int *result = 0 ;
3282
3283   arg1 = (uintp *)jarg1;
3284   {
3285     try {
3286       result = (unsigned int *)uintp_cast(arg1);
3287     } catch (std::out_of_range& e) {
3288       {
3289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3290       };
3291     } catch (std::exception& e) {
3292       {
3293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3294       };
3295     } catch (Dali::DaliException e) {
3296       {
3297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3298       };
3299     } catch (...) {
3300       {
3301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3302       };
3303     }
3304   }
3305
3306   jresult = (void *)result;
3307   return jresult;
3308 }
3309
3310
3311 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_frompointer(void * jarg1) {
3312   void * jresult ;
3313   unsigned int *arg1 = (unsigned int *) 0 ;
3314   uintp *result = 0 ;
3315
3316   arg1 = (unsigned int *)jarg1;
3317   {
3318     try {
3319       result = (uintp *)uintp_frompointer(arg1);
3320     } catch (std::out_of_range& e) {
3321       {
3322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3323       };
3324     } catch (std::exception& e) {
3325       {
3326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3327       };
3328     } catch (Dali::DaliException e) {
3329       {
3330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3331       };
3332     } catch (...) {
3333       {
3334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3335       };
3336     }
3337   }
3338
3339   jresult = (void *)result;
3340   return jresult;
3341 }
3342
3343
3344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ushortp() {
3345   void * jresult ;
3346   ushortp *result = 0 ;
3347
3348   {
3349     try {
3350       result = (ushortp *)new_ushortp();
3351     } catch (std::out_of_range& e) {
3352       {
3353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3354       };
3355     } catch (std::exception& e) {
3356       {
3357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3358       };
3359     } catch (Dali::DaliException e) {
3360       {
3361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3362       };
3363     } catch (...) {
3364       {
3365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3366       };
3367     }
3368   }
3369
3370   jresult = (void *)result;
3371   return jresult;
3372 }
3373
3374
3375 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ushortp(void * jarg1) {
3376   ushortp *arg1 = (ushortp *) 0 ;
3377
3378   arg1 = (ushortp *)jarg1;
3379   {
3380     try {
3381       delete_ushortp(arg1);
3382     } catch (std::out_of_range& e) {
3383       {
3384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3385       };
3386     } catch (std::exception& e) {
3387       {
3388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3389       };
3390     } catch (Dali::DaliException e) {
3391       {
3392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3393       };
3394     } catch (...) {
3395       {
3396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3397       };
3398     }
3399   }
3400
3401 }
3402
3403
3404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ushortp_assign(void * jarg1, unsigned short jarg2) {
3405   ushortp *arg1 = (ushortp *) 0 ;
3406   unsigned short arg2 ;
3407
3408   arg1 = (ushortp *)jarg1;
3409   arg2 = (unsigned short)jarg2;
3410   {
3411     try {
3412       ushortp_assign(arg1,arg2);
3413     } catch (std::out_of_range& e) {
3414       {
3415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3416       };
3417     } catch (std::exception& e) {
3418       {
3419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3420       };
3421     } catch (Dali::DaliException e) {
3422       {
3423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3424       };
3425     } catch (...) {
3426       {
3427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3428       };
3429     }
3430   }
3431
3432 }
3433
3434
3435 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_ushortp_value(void * jarg1) {
3436   unsigned short jresult ;
3437   ushortp *arg1 = (ushortp *) 0 ;
3438   unsigned short result;
3439
3440   arg1 = (ushortp *)jarg1;
3441   {
3442     try {
3443       result = (unsigned short)ushortp_value(arg1);
3444     } catch (std::out_of_range& e) {
3445       {
3446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3447       };
3448     } catch (std::exception& e) {
3449       {
3450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3451       };
3452     } catch (Dali::DaliException e) {
3453       {
3454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3455       };
3456     } catch (...) {
3457       {
3458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3459       };
3460     }
3461   }
3462
3463   jresult = result;
3464   return jresult;
3465 }
3466
3467
3468 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_cast(void * jarg1) {
3469   void * jresult ;
3470   ushortp *arg1 = (ushortp *) 0 ;
3471   unsigned short *result = 0 ;
3472
3473   arg1 = (ushortp *)jarg1;
3474   {
3475     try {
3476       result = (unsigned short *)ushortp_cast(arg1);
3477     } catch (std::out_of_range& e) {
3478       {
3479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3480       };
3481     } catch (std::exception& e) {
3482       {
3483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3484       };
3485     } catch (Dali::DaliException e) {
3486       {
3487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3488       };
3489     } catch (...) {
3490       {
3491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3492       };
3493     }
3494   }
3495
3496   jresult = (void *)result;
3497   return jresult;
3498 }
3499
3500
3501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_frompointer(void * jarg1) {
3502   void * jresult ;
3503   unsigned short *arg1 = (unsigned short *) 0 ;
3504   ushortp *result = 0 ;
3505
3506   arg1 = (unsigned short *)jarg1;
3507   {
3508     try {
3509       result = (ushortp *)ushortp_frompointer(arg1);
3510     } catch (std::out_of_range& e) {
3511       {
3512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3513       };
3514     } catch (std::exception& e) {
3515       {
3516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3517       };
3518     } catch (Dali::DaliException e) {
3519       {
3520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3521       };
3522     } catch (...) {
3523       {
3524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3525       };
3526     }
3527   }
3528
3529   jresult = (void *)result;
3530   return jresult;
3531 }
3532
3533
3534 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_int_to_uint(int jarg1) {
3535   unsigned int jresult ;
3536   int arg1 ;
3537   unsigned int result;
3538
3539   arg1 = (int)jarg1;
3540   {
3541     try {
3542       result = (unsigned int)int_to_uint(arg1);
3543     } catch (std::out_of_range& e) {
3544       {
3545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3546       };
3547     } catch (std::exception& e) {
3548       {
3549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3550       };
3551     } catch (Dali::DaliException e) {
3552       {
3553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3554       };
3555     } catch (...) {
3556       {
3557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3558       };
3559     }
3560   }
3561
3562   jresult = result;
3563   return jresult;
3564 }
3565
3566
3567 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Reference(void * jarg1) {
3568   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3569
3570   arg1 = (Dali::RefObject *)jarg1;
3571   {
3572     try {
3573       (arg1)->Reference();
3574     } catch (std::out_of_range& e) {
3575       {
3576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3577       };
3578     } catch (std::exception& e) {
3579       {
3580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3581       };
3582     } catch (Dali::DaliException e) {
3583       {
3584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3585       };
3586     } catch (...) {
3587       {
3588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3589       };
3590     }
3591   }
3592
3593 }
3594
3595
3596 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Unreference(void * jarg1) {
3597   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3598
3599   arg1 = (Dali::RefObject *)jarg1;
3600   {
3601     try {
3602       (arg1)->Unreference();
3603     } catch (std::out_of_range& e) {
3604       {
3605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3606       };
3607     } catch (std::exception& e) {
3608       {
3609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3610       };
3611     } catch (Dali::DaliException e) {
3612       {
3613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3614       };
3615     } catch (...) {
3616       {
3617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3618       };
3619     }
3620   }
3621
3622 }
3623
3624
3625 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RefObject_ReferenceCount(void * jarg1) {
3626   int jresult ;
3627   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3628   int result;
3629
3630   arg1 = (Dali::RefObject *)jarg1;
3631   {
3632     try {
3633       result = (int)(arg1)->ReferenceCount();
3634     } catch (std::out_of_range& e) {
3635       {
3636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3637       };
3638     } catch (std::exception& e) {
3639       {
3640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3641       };
3642     } catch (Dali::DaliException e) {
3643       {
3644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3645       };
3646     } catch (...) {
3647       {
3648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3649       };
3650     }
3651   }
3652
3653   jresult = result;
3654   return jresult;
3655 }
3656
3657
3658 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_0() {
3659   void * jresult ;
3660   Dali::Any *result = 0 ;
3661
3662   {
3663     try {
3664       result = (Dali::Any *)new Dali::Any();
3665     } catch (std::out_of_range& e) {
3666       {
3667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3668       };
3669     } catch (std::exception& e) {
3670       {
3671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3672       };
3673     } catch (Dali::DaliException e) {
3674       {
3675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3676       };
3677     } catch (...) {
3678       {
3679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3680       };
3681     }
3682   }
3683
3684   jresult = (void *)result;
3685   return jresult;
3686 }
3687
3688
3689 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any(void * jarg1) {
3690   Dali::Any *arg1 = (Dali::Any *) 0 ;
3691
3692   arg1 = (Dali::Any *)jarg1;
3693   {
3694     try {
3695       delete arg1;
3696     } catch (std::out_of_range& e) {
3697       {
3698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3699       };
3700     } catch (std::exception& e) {
3701       {
3702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3703       };
3704     } catch (Dali::DaliException e) {
3705       {
3706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3707       };
3708     } catch (...) {
3709       {
3710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3711       };
3712     }
3713   }
3714
3715 }
3716
3717
3718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AssertAlways(char * jarg1) {
3719   char *arg1 = (char *) 0 ;
3720
3721   arg1 = (char *)jarg1;
3722   {
3723     try {
3724       Dali::Any::AssertAlways((char const *)arg1);
3725     } catch (std::out_of_range& e) {
3726       {
3727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3728       };
3729     } catch (std::exception& e) {
3730       {
3731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3732       };
3733     } catch (Dali::DaliException e) {
3734       {
3735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3736       };
3737     } catch (...) {
3738       {
3739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3740       };
3741     }
3742   }
3743
3744 }
3745
3746
3747 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_2(void * jarg1) {
3748   void * jresult ;
3749   Dali::Any *arg1 = 0 ;
3750   Dali::Any *result = 0 ;
3751
3752   arg1 = (Dali::Any *)jarg1;
3753   if (!arg1) {
3754     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3755     return 0;
3756   }
3757   {
3758     try {
3759       result = (Dali::Any *)new Dali::Any((Dali::Any const &)*arg1);
3760     } catch (std::out_of_range& e) {
3761       {
3762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3763       };
3764     } catch (std::exception& e) {
3765       {
3766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3767       };
3768     } catch (Dali::DaliException e) {
3769       {
3770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3771       };
3772     } catch (...) {
3773       {
3774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3775       };
3776     }
3777   }
3778
3779   jresult = (void *)result;
3780   return jresult;
3781 }
3782
3783
3784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_Assign(void * jarg1, void * jarg2) {
3785   void * jresult ;
3786   Dali::Any *arg1 = (Dali::Any *) 0 ;
3787   Dali::Any *arg2 = 0 ;
3788   Dali::Any *result = 0 ;
3789
3790   arg1 = (Dali::Any *)jarg1;
3791   arg2 = (Dali::Any *)jarg2;
3792   if (!arg2) {
3793     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3794     return 0;
3795   }
3796   {
3797     try {
3798       result = (Dali::Any *) &(arg1)->operator =((Dali::Any const &)*arg2);
3799     } catch (std::out_of_range& e) {
3800       {
3801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3802       };
3803     } catch (std::exception& e) {
3804       {
3805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3806       };
3807     } catch (Dali::DaliException e) {
3808       {
3809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3810       };
3811     } catch (...) {
3812       {
3813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3814       };
3815     }
3816   }
3817
3818   jresult = (void *)result;
3819   return jresult;
3820 }
3821
3822
3823 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_GetType(void * jarg1) {
3824   void * jresult ;
3825   Dali::Any *arg1 = (Dali::Any *) 0 ;
3826   std::type_info *result = 0 ;
3827
3828   arg1 = (Dali::Any *)jarg1;
3829   {
3830     try {
3831       result = (std::type_info *) &((Dali::Any const *)arg1)->GetType();
3832     } catch (std::out_of_range& e) {
3833       {
3834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3835       };
3836     } catch (std::exception& e) {
3837       {
3838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3839       };
3840     } catch (Dali::DaliException e) {
3841       {
3842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3843       };
3844     } catch (...) {
3845       {
3846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3847       };
3848     }
3849   }
3850
3851   jresult = (void *)result;
3852   return jresult;
3853 }
3854
3855
3856 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Any_Empty(void * jarg1) {
3857   unsigned int jresult ;
3858   Dali::Any *arg1 = (Dali::Any *) 0 ;
3859   bool result;
3860
3861   arg1 = (Dali::Any *)jarg1;
3862   {
3863     try {
3864       result = (bool)((Dali::Any const *)arg1)->Empty();
3865     } catch (std::out_of_range& e) {
3866       {
3867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3868       };
3869     } catch (std::exception& e) {
3870       {
3871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3872       };
3873     } catch (Dali::DaliException e) {
3874       {
3875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3876       };
3877     } catch (...) {
3878       {
3879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3880       };
3881     }
3882   }
3883
3884   jresult = result;
3885   return jresult;
3886 }
3887
3888
3889 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any_AnyContainerBase(void * jarg1, void * jarg2, void * jarg3) {
3890   void * jresult ;
3891   std::type_info *arg1 = 0 ;
3892   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3893   Dali::Any::DeleteFunc arg3 = (Dali::Any::DeleteFunc) 0 ;
3894   Dali::Any::AnyContainerBase *result = 0 ;
3895
3896   arg1 = (std::type_info *)jarg1;
3897   if (!arg1) {
3898     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
3899     return 0;
3900   }
3901   arg2 = (Dali::Any::CloneFunc)jarg2;
3902   arg3 = (Dali::Any::DeleteFunc)jarg3;
3903   {
3904     try {
3905       result = (Dali::Any::AnyContainerBase *)new Dali::Any::AnyContainerBase((std::type_info const &)*arg1,arg2,arg3);
3906     } catch (std::out_of_range& e) {
3907       {
3908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3909       };
3910     } catch (std::exception& e) {
3911       {
3912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3913       };
3914     } catch (Dali::DaliException e) {
3915       {
3916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3917       };
3918     } catch (...) {
3919       {
3920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3921       };
3922     }
3923   }
3924
3925   jresult = (void *)result;
3926   return jresult;
3927 }
3928
3929
3930 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_GetType(void * jarg1) {
3931   void * jresult ;
3932   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3933   std::type_info *result = 0 ;
3934
3935   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3936   {
3937     try {
3938       result = (std::type_info *) &((Dali::Any::AnyContainerBase const *)arg1)->GetType();
3939     } catch (std::out_of_range& e) {
3940       {
3941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3942       };
3943     } catch (std::exception& e) {
3944       {
3945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3946       };
3947     } catch (Dali::DaliException e) {
3948       {
3949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3950       };
3951     } catch (...) {
3952       {
3953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3954       };
3955     }
3956   }
3957
3958   jresult = (void *)result;
3959   return jresult;
3960 }
3961
3962
3963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mType_get(void * jarg1) {
3964   void * jresult ;
3965   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3966   ::std::type_info *result = 0 ;
3967
3968   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3969   result = (::std::type_info *) &(::std::type_info const &) ((arg1)->mType);
3970   jresult = (void *)result;
3971   return jresult;
3972 }
3973
3974
3975 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_set(void * jarg1, void * jarg2) {
3976   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3977   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3978
3979   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3980   arg2 = (Dali::Any::CloneFunc)jarg2;
3981   if (arg1) (arg1)->mCloneFunc = arg2;
3982 }
3983
3984
3985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_get(void * jarg1) {
3986   void * jresult ;
3987   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3988   Dali::Any::CloneFunc result;
3989
3990   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3991   result = (Dali::Any::CloneFunc) ((arg1)->mCloneFunc);
3992   jresult = (void *)result;
3993   return jresult;
3994 }
3995
3996
3997 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_set(void * jarg1, void * jarg2) {
3998   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3999   Dali::Any::DeleteFunc arg2 = (Dali::Any::DeleteFunc) 0 ;
4000
4001   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
4002   arg2 = (Dali::Any::DeleteFunc)jarg2;
4003   if (arg1) (arg1)->mDeleteFunc = arg2;
4004 }
4005
4006
4007 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_get(void * jarg1) {
4008   void * jresult ;
4009   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
4010   Dali::Any::DeleteFunc result;
4011
4012   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
4013   result = (Dali::Any::DeleteFunc) ((arg1)->mDeleteFunc);
4014   jresult = (void *)result;
4015   return jresult;
4016 }
4017
4018
4019 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any_AnyContainerBase(void * jarg1) {
4020   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
4021
4022   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
4023   {
4024     try {
4025       delete arg1;
4026     } catch (std::out_of_range& e) {
4027       {
4028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4029       };
4030     } catch (std::exception& e) {
4031       {
4032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4033       };
4034     } catch (Dali::DaliException e) {
4035       {
4036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
4037       };
4038     } catch (...) {
4039       {
4040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4041       };
4042     }
4043   }
4044
4045 }
4046
4047
4048 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_mContainer_set(void * jarg1, void * jarg2) {
4049   Dali::Any *arg1 = (Dali::Any *) 0 ;
4050   Dali::Any::AnyContainerBase *arg2 = (Dali::Any::AnyContainerBase *) 0 ;
4051
4052   arg1 = (Dali::Any *)jarg1;
4053   arg2 = (Dali::Any::AnyContainerBase *)jarg2;
4054   if (arg1) (arg1)->mContainer = arg2;
4055 }
4056
4057
4058 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_mContainer_get(void * jarg1) {
4059   void * jresult ;
4060   Dali::Any *arg1 = (Dali::Any *) 0 ;
4061   Dali::Any::AnyContainerBase *result = 0 ;
4062
4063   arg1 = (Dali::Any *)jarg1;
4064   result = (Dali::Any::AnyContainerBase *) ((arg1)->mContainer);
4065   jresult = (void *)result;
4066   return jresult;
4067 }
4068
4069
4070 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliAssertMessage(char * jarg1, char * jarg2) {
4071   char *arg1 = (char *) 0 ;
4072   char *arg2 = (char *) 0 ;
4073
4074   arg1 = (char *)jarg1;
4075   arg2 = (char *)jarg2;
4076   {
4077     try {
4078       Dali::DaliAssertMessage((char const *)arg1,(char const *)arg2);
4079     } catch (std::out_of_range& e) {
4080       {
4081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4082       };
4083     } catch (std::exception& e) {
4084       {
4085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4086       };
4087     } catch (Dali::DaliException e) {
4088       {
4089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
4090       };
4091     } catch (...) {
4092       {
4093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4094       };
4095     }
4096   }
4097
4098 }
4099
4100
4101 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DaliException(char * jarg1, char * jarg2) {
4102   void * jresult ;
4103   char *arg1 = (char *) 0 ;
4104   char *arg2 = (char *) 0 ;
4105   Dali::DaliException *result = 0 ;
4106
4107   arg1 = (char *)jarg1;
4108   arg2 = (char *)jarg2;
4109   {
4110     try {
4111       result = (Dali::DaliException *)new Dali::DaliException((char const *)arg1,(char const *)arg2);
4112     } catch (std::out_of_range& e) {
4113       {
4114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4115       };
4116     } catch (std::exception& e) {
4117       {
4118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4119       };
4120     } catch (Dali::DaliException e) {
4121       {
4122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4123       };
4124     } catch (...) {
4125       {
4126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4127       };
4128     }
4129   }
4130
4131   jresult = (void *)result;
4132   return jresult;
4133 }
4134
4135
4136 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_location_set(void * jarg1, char * jarg2) {
4137   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4138   std::string arg2 = std::string(jarg2);
4139
4140   arg1 = (Dali::DaliException *)jarg1;
4141   {
4142     if (!arg2.empty()) {
4143       ((char *)(arg1->location))[arg2.copy((char*)(arg1->location), strlen(arg1->location)-1)] = '\0';
4144     } else {
4145       arg1->location = 0;
4146     }
4147   }
4148 }
4149
4150 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_location_get(void * jarg1) {
4151   char * jresult ;
4152   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4153   char *result = 0 ;
4154
4155   arg1 = (Dali::DaliException *)jarg1;
4156   result = (char *) ((arg1)->location);
4157   jresult = SWIG_csharp_string_callback((const char *)result);
4158   return jresult;
4159 }
4160
4161
4162 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_condition_set(void * jarg1, char * jarg2) {
4163   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4164   std::string arg2 = std::string(jarg2);
4165
4166   arg1 = (Dali::DaliException *)jarg1;
4167   {
4168     if (!arg2.empty()) {
4169       ((char *)(arg1->condition))[arg2.copy((char*)(arg1->condition), strlen(arg1->condition)-1)] = '\0';
4170     } else {
4171       arg1->condition = 0;
4172     }
4173   }
4174 }
4175
4176
4177 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_condition_get(void * jarg1) {
4178   char * jresult ;
4179   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4180   char *result = 0 ;
4181
4182   arg1 = (Dali::DaliException *)jarg1;
4183   result = (char *) ((arg1)->condition);
4184   jresult = SWIG_csharp_string_callback((const char *)result);
4185   return jresult;
4186 }
4187
4188
4189 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DaliException(void * jarg1) {
4190   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4191
4192   arg1 = (Dali::DaliException *)jarg1;
4193   {
4194     try {
4195       delete arg1;
4196     } catch (std::out_of_range& e) {
4197       {
4198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4199       };
4200     } catch (std::exception& e) {
4201       {
4202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4203       };
4204     } catch (Dali::DaliException e) {
4205       {
4206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
4207       };
4208     } catch (...) {
4209       {
4210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4211       };
4212     }
4213   }
4214
4215 }
4216
4217
4218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_0() {
4219   void * jresult ;
4220   Dali::Vector2 *result = 0 ;
4221
4222   {
4223     try {
4224       result = (Dali::Vector2 *)new Dali::Vector2();
4225     } catch (std::out_of_range& e) {
4226       {
4227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4228       };
4229     } catch (std::exception& e) {
4230       {
4231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4232       };
4233     } catch (Dali::DaliException e) {
4234       {
4235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4236       };
4237     } catch (...) {
4238       {
4239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4240       };
4241     }
4242   }
4243
4244   jresult = (void *)result;
4245   return jresult;
4246 }
4247
4248
4249 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_1(float jarg1, float jarg2) {
4250   void * jresult ;
4251   float arg1 ;
4252   float arg2 ;
4253   Dali::Vector2 *result = 0 ;
4254
4255   arg1 = (float)jarg1;
4256   arg2 = (float)jarg2;
4257   {
4258     try {
4259       result = (Dali::Vector2 *)new Dali::Vector2(arg1,arg2);
4260     } catch (std::out_of_range& e) {
4261       {
4262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4263       };
4264     } catch (std::exception& e) {
4265       {
4266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4267       };
4268     } catch (Dali::DaliException e) {
4269       {
4270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4271       };
4272     } catch (...) {
4273       {
4274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4275       };
4276     }
4277   }
4278
4279   jresult = (void *)result;
4280   return jresult;
4281 }
4282
4283
4284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_2(float* jarg1) {
4285   void * jresult ;
4286   float *arg1 = (float *) 0 ;
4287   Dali::Vector2 *result = 0 ;
4288
4289   arg1 = jarg1;
4290   {
4291     try {
4292       result = (Dali::Vector2 *)new Dali::Vector2((float const *)arg1);
4293     } catch (std::out_of_range& e) {
4294       {
4295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4296       };
4297     } catch (std::exception& e) {
4298       {
4299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4300       };
4301     } catch (Dali::DaliException e) {
4302       {
4303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4304       };
4305     } catch (...) {
4306       {
4307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4308       };
4309     }
4310   }
4311
4312   jresult = (void *)result;
4313
4314
4315   return jresult;
4316 }
4317
4318
4319 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_3(void * jarg1) {
4320   void * jresult ;
4321   Dali::Vector3 *arg1 = 0 ;
4322   Dali::Vector2 *result = 0 ;
4323
4324   arg1 = (Dali::Vector3 *)jarg1;
4325   if (!arg1) {
4326     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4327     return 0;
4328   }
4329   {
4330     try {
4331       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector3 const &)*arg1);
4332     } catch (std::out_of_range& e) {
4333       {
4334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4335       };
4336     } catch (std::exception& e) {
4337       {
4338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4339       };
4340     } catch (Dali::DaliException e) {
4341       {
4342         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4343       };
4344     } catch (...) {
4345       {
4346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4347       };
4348     }
4349   }
4350
4351   jresult = (void *)result;
4352   return jresult;
4353 }
4354
4355
4356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_4(void * jarg1) {
4357   void * jresult ;
4358   Dali::Vector4 *arg1 = 0 ;
4359   Dali::Vector2 *result = 0 ;
4360
4361   arg1 = (Dali::Vector4 *)jarg1;
4362   if (!arg1) {
4363     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4364     return 0;
4365   }
4366   {
4367     try {
4368       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector4 const &)*arg1);
4369     } catch (std::out_of_range& e) {
4370       {
4371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4372       };
4373     } catch (std::exception& e) {
4374       {
4375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4376       };
4377     } catch (Dali::DaliException e) {
4378       {
4379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4380       };
4381     } catch (...) {
4382       {
4383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4384       };
4385     }
4386   }
4387
4388   jresult = (void *)result;
4389   return jresult;
4390 }
4391
4392
4393 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ONE_get() {
4394   void * jresult ;
4395   Dali::Vector2 *result = 0 ;
4396
4397   result = (Dali::Vector2 *)&Dali::Vector2::ONE;
4398   jresult = (void *)result;
4399   return jresult;
4400 }
4401
4402
4403 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_XAXIS_get() {
4404   void * jresult ;
4405   Dali::Vector2 *result = 0 ;
4406
4407   result = (Dali::Vector2 *)&Dali::Vector2::XAXIS;
4408   jresult = (void *)result;
4409   return jresult;
4410 }
4411
4412
4413 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_YAXIS_get() {
4414   void * jresult ;
4415   Dali::Vector2 *result = 0 ;
4416
4417   result = (Dali::Vector2 *)&Dali::Vector2::YAXIS;
4418   jresult = (void *)result;
4419   return jresult;
4420 }
4421
4422
4423 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_XAXIS_get() {
4424   void * jresult ;
4425   Dali::Vector2 *result = 0 ;
4426
4427   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_XAXIS;
4428   jresult = (void *)result;
4429   return jresult;
4430 }
4431
4432
4433 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_YAXIS_get() {
4434   void * jresult ;
4435   Dali::Vector2 *result = 0 ;
4436
4437   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_YAXIS;
4438   jresult = (void *)result;
4439   return jresult;
4440 }
4441
4442
4443 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ZERO_get() {
4444   void * jresult ;
4445   Dali::Vector2 *result = 0 ;
4446
4447   result = (Dali::Vector2 *)&Dali::Vector2::ZERO;
4448   jresult = (void *)result;
4449   return jresult;
4450 }
4451
4452
4453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_0(void * jarg1, float* jarg2) {
4454   void * jresult ;
4455   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4456   float *arg2 = (float *) 0 ;
4457   Dali::Vector2 *result = 0 ;
4458
4459   arg1 = (Dali::Vector2 *)jarg1;
4460   arg2 = jarg2;
4461   {
4462     try {
4463       result = (Dali::Vector2 *) &(arg1)->operator =((float const *)arg2);
4464     } catch (std::out_of_range& e) {
4465       {
4466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4467       };
4468     } catch (std::exception& e) {
4469       {
4470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4471       };
4472     } catch (Dali::DaliException e) {
4473       {
4474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4475       };
4476     } catch (...) {
4477       {
4478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4479       };
4480     }
4481   }
4482
4483   jresult = (void *)result;
4484
4485
4486   return jresult;
4487 }
4488
4489
4490 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_1(void * jarg1, void * jarg2) {
4491   void * jresult ;
4492   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4493   Dali::Vector3 *arg2 = 0 ;
4494   Dali::Vector2 *result = 0 ;
4495
4496   arg1 = (Dali::Vector2 *)jarg1;
4497   arg2 = (Dali::Vector3 *)jarg2;
4498   if (!arg2) {
4499     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4500     return 0;
4501   }
4502   {
4503     try {
4504       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
4505     } catch (std::out_of_range& e) {
4506       {
4507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4508       };
4509     } catch (std::exception& e) {
4510       {
4511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4512       };
4513     } catch (Dali::DaliException e) {
4514       {
4515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4516       };
4517     } catch (...) {
4518       {
4519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4520       };
4521     }
4522   }
4523
4524   jresult = (void *)result;
4525   return jresult;
4526 }
4527
4528
4529 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_2(void * jarg1, void * jarg2) {
4530   void * jresult ;
4531   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4532   Dali::Vector4 *arg2 = 0 ;
4533   Dali::Vector2 *result = 0 ;
4534
4535   arg1 = (Dali::Vector2 *)jarg1;
4536   arg2 = (Dali::Vector4 *)jarg2;
4537   if (!arg2) {
4538     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4539     return 0;
4540   }
4541   {
4542     try {
4543       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
4544     } catch (std::out_of_range& e) {
4545       {
4546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4547       };
4548     } catch (std::exception& e) {
4549       {
4550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4551       };
4552     } catch (Dali::DaliException e) {
4553       {
4554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4555       };
4556     } catch (...) {
4557       {
4558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4559       };
4560     }
4561   }
4562
4563   jresult = (void *)result;
4564   return jresult;
4565 }
4566
4567
4568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Add(void * jarg1, void * jarg2) {
4569   void * jresult ;
4570   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4571   Dali::Vector2 *arg2 = 0 ;
4572   Dali::Vector2 result;
4573
4574   arg1 = (Dali::Vector2 *)jarg1;
4575   arg2 = (Dali::Vector2 *)jarg2;
4576   if (!arg2) {
4577     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4578     return 0;
4579   }
4580   {
4581     try {
4582       result = ((Dali::Vector2 const *)arg1)->operator +((Dali::Vector2 const &)*arg2);
4583     } catch (std::out_of_range& e) {
4584       {
4585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4586       };
4587     } catch (std::exception& e) {
4588       {
4589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4590       };
4591     } catch (Dali::DaliException e) {
4592       {
4593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4594       };
4595     } catch (...) {
4596       {
4597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4598       };
4599     }
4600   }
4601
4602   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4603   return jresult;
4604 }
4605
4606
4607 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AddAssign(void * jarg1, void * jarg2) {
4608   void * jresult ;
4609   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4610   Dali::Vector2 *arg2 = 0 ;
4611   Dali::Vector2 *result = 0 ;
4612
4613   arg1 = (Dali::Vector2 *)jarg1;
4614   arg2 = (Dali::Vector2 *)jarg2;
4615   if (!arg2) {
4616     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4617     return 0;
4618   }
4619   {
4620     try {
4621       result = (Dali::Vector2 *) &(arg1)->operator +=((Dali::Vector2 const &)*arg2);
4622     } catch (std::out_of_range& e) {
4623       {
4624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4625       };
4626     } catch (std::exception& e) {
4627       {
4628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4629       };
4630     } catch (Dali::DaliException e) {
4631       {
4632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4633       };
4634     } catch (...) {
4635       {
4636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4637       };
4638     }
4639   }
4640
4641   jresult = (void *)result;
4642   return jresult;
4643 }
4644
4645
4646 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_0(void * jarg1, void * jarg2) {
4647   void * jresult ;
4648   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4649   Dali::Vector2 *arg2 = 0 ;
4650   Dali::Vector2 result;
4651
4652   arg1 = (Dali::Vector2 *)jarg1;
4653   arg2 = (Dali::Vector2 *)jarg2;
4654   if (!arg2) {
4655     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4656     return 0;
4657   }
4658   {
4659     try {
4660       result = ((Dali::Vector2 const *)arg1)->operator -((Dali::Vector2 const &)*arg2);
4661     } catch (std::out_of_range& e) {
4662       {
4663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4664       };
4665     } catch (std::exception& e) {
4666       {
4667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4668       };
4669     } catch (Dali::DaliException e) {
4670       {
4671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4672       };
4673     } catch (...) {
4674       {
4675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4676       };
4677     }
4678   }
4679
4680   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4681   return jresult;
4682 }
4683
4684
4685 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_SubtractAssign(void * jarg1, void * jarg2) {
4686   void * jresult ;
4687   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4688   Dali::Vector2 *arg2 = 0 ;
4689   Dali::Vector2 *result = 0 ;
4690
4691   arg1 = (Dali::Vector2 *)jarg1;
4692   arg2 = (Dali::Vector2 *)jarg2;
4693   if (!arg2) {
4694     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4695     return 0;
4696   }
4697   {
4698     try {
4699       result = (Dali::Vector2 *) &(arg1)->operator -=((Dali::Vector2 const &)*arg2);
4700     } catch (std::out_of_range& e) {
4701       {
4702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4703       };
4704     } catch (std::exception& e) {
4705       {
4706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4707       };
4708     } catch (Dali::DaliException e) {
4709       {
4710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4711       };
4712     } catch (...) {
4713       {
4714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4715       };
4716     }
4717   }
4718
4719   jresult = (void *)result;
4720   return jresult;
4721 }
4722
4723
4724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_0(void * jarg1, void * jarg2) {
4725   void * jresult ;
4726   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4727   Dali::Vector2 *arg2 = 0 ;
4728   Dali::Vector2 result;
4729
4730   arg1 = (Dali::Vector2 *)jarg1;
4731   arg2 = (Dali::Vector2 *)jarg2;
4732   if (!arg2) {
4733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4734     return 0;
4735   }
4736   {
4737     try {
4738       result = ((Dali::Vector2 const *)arg1)->operator *((Dali::Vector2 const &)*arg2);
4739     } catch (std::out_of_range& e) {
4740       {
4741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4742       };
4743     } catch (std::exception& e) {
4744       {
4745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4746       };
4747     } catch (Dali::DaliException e) {
4748       {
4749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4750       };
4751     } catch (...) {
4752       {
4753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4754       };
4755     }
4756   }
4757
4758   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4759   return jresult;
4760 }
4761
4762
4763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_1(void * jarg1, float jarg2) {
4764   void * jresult ;
4765   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4766   float arg2 ;
4767   Dali::Vector2 result;
4768
4769   arg1 = (Dali::Vector2 *)jarg1;
4770   arg2 = (float)jarg2;
4771   {
4772     try {
4773       result = ((Dali::Vector2 const *)arg1)->operator *(arg2);
4774     } catch (std::out_of_range& e) {
4775       {
4776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4777       };
4778     } catch (std::exception& e) {
4779       {
4780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4781       };
4782     } catch (Dali::DaliException e) {
4783       {
4784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4785       };
4786     } catch (...) {
4787       {
4788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4789       };
4790     }
4791   }
4792
4793   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4794   return jresult;
4795 }
4796
4797
4798 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
4799   void * jresult ;
4800   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4801   Dali::Vector2 *arg2 = 0 ;
4802   Dali::Vector2 *result = 0 ;
4803
4804   arg1 = (Dali::Vector2 *)jarg1;
4805   arg2 = (Dali::Vector2 *)jarg2;
4806   if (!arg2) {
4807     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4808     return 0;
4809   }
4810   {
4811     try {
4812       result = (Dali::Vector2 *) &(arg1)->operator *=((Dali::Vector2 const &)*arg2);
4813     } catch (std::out_of_range& e) {
4814       {
4815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4816       };
4817     } catch (std::exception& e) {
4818       {
4819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4820       };
4821     } catch (Dali::DaliException e) {
4822       {
4823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4824       };
4825     } catch (...) {
4826       {
4827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4828       };
4829     }
4830   }
4831
4832   jresult = (void *)result;
4833   return jresult;
4834 }
4835
4836
4837 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
4838   void * jresult ;
4839   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4840   float arg2 ;
4841   Dali::Vector2 *result = 0 ;
4842
4843   arg1 = (Dali::Vector2 *)jarg1;
4844   arg2 = (float)jarg2;
4845   {
4846     try {
4847       result = (Dali::Vector2 *) &(arg1)->operator *=(arg2);
4848     } catch (std::out_of_range& e) {
4849       {
4850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4851       };
4852     } catch (std::exception& e) {
4853       {
4854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4855       };
4856     } catch (Dali::DaliException e) {
4857       {
4858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4859       };
4860     } catch (...) {
4861       {
4862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4863       };
4864     }
4865   }
4866
4867   jresult = (void *)result;
4868   return jresult;
4869 }
4870
4871
4872 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_0(void * jarg1, void * jarg2) {
4873   void * jresult ;
4874   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4875   Dali::Vector2 *arg2 = 0 ;
4876   Dali::Vector2 result;
4877
4878   arg1 = (Dali::Vector2 *)jarg1;
4879   arg2 = (Dali::Vector2 *)jarg2;
4880   if (!arg2) {
4881     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4882     return 0;
4883   }
4884   {
4885     try {
4886       result = ((Dali::Vector2 const *)arg1)->operator /((Dali::Vector2 const &)*arg2);
4887     } catch (std::out_of_range& e) {
4888       {
4889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4890       };
4891     } catch (std::exception& e) {
4892       {
4893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4894       };
4895     } catch (Dali::DaliException e) {
4896       {
4897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4898       };
4899     } catch (...) {
4900       {
4901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4902       };
4903     }
4904   }
4905
4906   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4907   return jresult;
4908 }
4909
4910
4911 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_1(void * jarg1, float jarg2) {
4912   void * jresult ;
4913   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4914   float arg2 ;
4915   Dali::Vector2 result;
4916
4917   arg1 = (Dali::Vector2 *)jarg1;
4918   arg2 = (float)jarg2;
4919   {
4920     try {
4921       result = ((Dali::Vector2 const *)arg1)->operator /(arg2);
4922     } catch (std::out_of_range& e) {
4923       {
4924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4925       };
4926     } catch (std::exception& e) {
4927       {
4928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4929       };
4930     } catch (Dali::DaliException e) {
4931       {
4932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4933       };
4934     } catch (...) {
4935       {
4936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4937       };
4938     }
4939   }
4940
4941   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4942   return jresult;
4943 }
4944
4945
4946 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
4947   void * jresult ;
4948   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4949   Dali::Vector2 *arg2 = 0 ;
4950   Dali::Vector2 *result = 0 ;
4951
4952   arg1 = (Dali::Vector2 *)jarg1;
4953   arg2 = (Dali::Vector2 *)jarg2;
4954   if (!arg2) {
4955     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4956     return 0;
4957   }
4958   {
4959     try {
4960       result = (Dali::Vector2 *) &(arg1)->operator /=((Dali::Vector2 const &)*arg2);
4961     } catch (std::out_of_range& e) {
4962       {
4963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4964       };
4965     } catch (std::exception& e) {
4966       {
4967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4968       };
4969     } catch (Dali::DaliException e) {
4970       {
4971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4972       };
4973     } catch (...) {
4974       {
4975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4976       };
4977     }
4978   }
4979
4980   jresult = (void *)result;
4981   return jresult;
4982 }
4983
4984
4985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
4986   void * jresult ;
4987   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4988   float arg2 ;
4989   Dali::Vector2 *result = 0 ;
4990
4991   arg1 = (Dali::Vector2 *)jarg1;
4992   arg2 = (float)jarg2;
4993   {
4994     try {
4995       result = (Dali::Vector2 *) &(arg1)->operator /=(arg2);
4996     } catch (std::out_of_range& e) {
4997       {
4998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4999       };
5000     } catch (std::exception& e) {
5001       {
5002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5003       };
5004     } catch (Dali::DaliException e) {
5005       {
5006         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5007       };
5008     } catch (...) {
5009       {
5010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5011       };
5012     }
5013   }
5014
5015   jresult = (void *)result;
5016   return jresult;
5017 }
5018
5019
5020 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_1(void * jarg1) {
5021   void * jresult ;
5022   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5023   Dali::Vector2 result;
5024
5025   arg1 = (Dali::Vector2 *)jarg1;
5026   {
5027     try {
5028       result = ((Dali::Vector2 const *)arg1)->operator -();
5029     } catch (std::out_of_range& e) {
5030       {
5031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5032       };
5033     } catch (std::exception& e) {
5034       {
5035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5036       };
5037     } catch (Dali::DaliException e) {
5038       {
5039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5040       };
5041     } catch (...) {
5042       {
5043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5044       };
5045     }
5046   }
5047
5048   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5049   return jresult;
5050 }
5051
5052
5053 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_EqualTo(void * jarg1, void * jarg2) {
5054   unsigned int jresult ;
5055   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5056   Dali::Vector2 *arg2 = 0 ;
5057   bool result;
5058
5059   arg1 = (Dali::Vector2 *)jarg1;
5060   arg2 = (Dali::Vector2 *)jarg2;
5061   if (!arg2) {
5062     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5063     return 0;
5064   }
5065   {
5066     try {
5067       result = (bool)((Dali::Vector2 const *)arg1)->operator ==((Dali::Vector2 const &)*arg2);
5068     } catch (std::out_of_range& e) {
5069       {
5070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5071       };
5072     } catch (std::exception& e) {
5073       {
5074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5075       };
5076     } catch (Dali::DaliException e) {
5077       {
5078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5079       };
5080     } catch (...) {
5081       {
5082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5083       };
5084     }
5085   }
5086
5087   jresult = result;
5088   return jresult;
5089 }
5090
5091
5092 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_NotEqualTo(void * jarg1, void * jarg2) {
5093   unsigned int jresult ;
5094   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5095   Dali::Vector2 *arg2 = 0 ;
5096   bool result;
5097
5098   arg1 = (Dali::Vector2 *)jarg1;
5099   arg2 = (Dali::Vector2 *)jarg2;
5100   if (!arg2) {
5101     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5102     return 0;
5103   }
5104   {
5105     try {
5106       result = (bool)((Dali::Vector2 const *)arg1)->operator !=((Dali::Vector2 const &)*arg2);
5107     } catch (std::out_of_range& e) {
5108       {
5109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5110       };
5111     } catch (std::exception& e) {
5112       {
5113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5114       };
5115     } catch (Dali::DaliException e) {
5116       {
5117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5118       };
5119     } catch (...) {
5120       {
5121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5122       };
5123     }
5124   }
5125
5126   jresult = result;
5127   return jresult;
5128 }
5129
5130
5131 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
5132   float jresult ;
5133   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5134   unsigned int arg2 ;
5135   float *result = 0 ;
5136
5137   arg1 = (Dali::Vector2 *)jarg1;
5138   arg2 = (unsigned int)jarg2;
5139   {
5140     try {
5141       result = (float *) &((Dali::Vector2 const *)arg1)->operator [](arg2);
5142     } catch (std::out_of_range& e) {
5143       {
5144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5145       };
5146     } catch (std::exception& e) {
5147       {
5148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5149       };
5150     } catch (Dali::DaliException e) {
5151       {
5152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5153       };
5154     } catch (...) {
5155       {
5156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5157       };
5158     }
5159   }
5160
5161   jresult = *result;
5162   return jresult;
5163 }
5164
5165
5166 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Length(void * jarg1) {
5167   float jresult ;
5168   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5169   float result;
5170
5171   arg1 = (Dali::Vector2 *)jarg1;
5172   {
5173     try {
5174       result = (float)((Dali::Vector2 const *)arg1)->Length();
5175     } catch (std::out_of_range& e) {
5176       {
5177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5178       };
5179     } catch (std::exception& e) {
5180       {
5181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5182       };
5183     } catch (Dali::DaliException e) {
5184       {
5185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5186       };
5187     } catch (...) {
5188       {
5189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5190       };
5191     }
5192   }
5193
5194   jresult = result;
5195   return jresult;
5196 }
5197
5198
5199 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_LengthSquared(void * jarg1) {
5200   float jresult ;
5201   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5202   float result;
5203
5204   arg1 = (Dali::Vector2 *)jarg1;
5205   {
5206     try {
5207       result = (float)((Dali::Vector2 const *)arg1)->LengthSquared();
5208     } catch (std::out_of_range& e) {
5209       {
5210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5211       };
5212     } catch (std::exception& e) {
5213       {
5214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5215       };
5216     } catch (Dali::DaliException e) {
5217       {
5218         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5219       };
5220     } catch (...) {
5221       {
5222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5223       };
5224     }
5225   }
5226
5227   jresult = result;
5228   return jresult;
5229 }
5230
5231
5232 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Normalize(void * jarg1) {
5233   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5234
5235   arg1 = (Dali::Vector2 *)jarg1;
5236   {
5237     try {
5238       (arg1)->Normalize();
5239     } catch (std::out_of_range& e) {
5240       {
5241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5242       };
5243     } catch (std::exception& e) {
5244       {
5245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5246       };
5247     } catch (Dali::DaliException e) {
5248       {
5249         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5250       };
5251     } catch (...) {
5252       {
5253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5254       };
5255     }
5256   }
5257
5258 }
5259
5260
5261 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Clamp(void * jarg1, void * jarg2, void * jarg3) {
5262   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5263   Dali::Vector2 *arg2 = 0 ;
5264   Dali::Vector2 *arg3 = 0 ;
5265
5266   arg1 = (Dali::Vector2 *)jarg1;
5267   arg2 = (Dali::Vector2 *)jarg2;
5268   if (!arg2) {
5269     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5270     return ;
5271   }
5272   arg3 = (Dali::Vector2 *)jarg3;
5273   if (!arg3) {
5274     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5275     return ;
5276   }
5277   {
5278     try {
5279       (arg1)->Clamp((Dali::Vector2 const &)*arg2,(Dali::Vector2 const &)*arg3);
5280     } catch (std::out_of_range& e) {
5281       {
5282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5283       };
5284     } catch (std::exception& e) {
5285       {
5286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5287       };
5288     } catch (Dali::DaliException e) {
5289       {
5290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5291       };
5292     } catch (...) {
5293       {
5294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5295       };
5296     }
5297   }
5298
5299 }
5300
5301
5302 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AsFloat__SWIG_0(void * jarg1) {
5303   void * jresult ;
5304   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5305   float *result = 0 ;
5306
5307   arg1 = (Dali::Vector2 *)jarg1;
5308   {
5309     try {
5310       result = (float *)((Dali::Vector2 const *)arg1)->AsFloat();
5311     } catch (std::out_of_range& e) {
5312       {
5313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5314       };
5315     } catch (std::exception& e) {
5316       {
5317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5318       };
5319     } catch (Dali::DaliException e) {
5320       {
5321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5322       };
5323     } catch (...) {
5324       {
5325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5326       };
5327     }
5328   }
5329
5330   jresult = (void *)result;
5331   return jresult;
5332 }
5333
5334
5335 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_X_set(void * jarg1, float jarg2) {
5336   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5337   float arg2 ;
5338
5339   arg1 = (Dali::Vector2 *)jarg1;
5340   arg2 = (float)jarg2;
5341   if (arg1) (arg1)->x = arg2;
5342 }
5343
5344
5345 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_X_get(void * jarg1) {
5346   float jresult ;
5347   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5348   float result;
5349
5350   arg1 = (Dali::Vector2 *)jarg1;
5351   result = (float) ((arg1)->x);
5352   jresult = result;
5353   return jresult;
5354 }
5355
5356
5357 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Width_set(void * jarg1, float jarg2) {
5358   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5359   float arg2 ;
5360
5361   arg1 = (Dali::Vector2 *)jarg1;
5362   arg2 = (float)jarg2;
5363   if (arg1) (arg1)->width = arg2;
5364 }
5365
5366
5367 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Width_get(void * jarg1) {
5368   float jresult ;
5369   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5370   float result;
5371
5372   arg1 = (Dali::Vector2 *)jarg1;
5373   result = (float) ((arg1)->width);
5374   jresult = result;
5375   return jresult;
5376 }
5377
5378
5379 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Y_set(void * jarg1, float jarg2) {
5380   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5381   float arg2 ;
5382
5383   arg1 = (Dali::Vector2 *)jarg1;
5384   arg2 = (float)jarg2;
5385   if (arg1) (arg1)->y = arg2;
5386 }
5387
5388
5389 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Y_get(void * jarg1) {
5390   float jresult ;
5391   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5392   float result;
5393
5394   arg1 = (Dali::Vector2 *)jarg1;
5395   result = (float) ((arg1)->y);
5396   jresult = result;
5397   return jresult;
5398 }
5399
5400
5401 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Height_set(void * jarg1, float jarg2) {
5402   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5403   float arg2 ;
5404
5405   arg1 = (Dali::Vector2 *)jarg1;
5406   arg2 = (float)jarg2;
5407   if (arg1) (arg1)->height = arg2;
5408 }
5409
5410
5411 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Height_get(void * jarg1) {
5412   float jresult ;
5413   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5414   float result;
5415
5416   arg1 = (Dali::Vector2 *)jarg1;
5417   result = (float) ((arg1)->height);
5418   jresult = result;
5419   return jresult;
5420 }
5421
5422
5423 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector2(void * jarg1) {
5424   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5425
5426   arg1 = (Dali::Vector2 *)jarg1;
5427   {
5428     try {
5429       delete arg1;
5430     } catch (std::out_of_range& e) {
5431       {
5432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5433       };
5434     } catch (std::exception& e) {
5435       {
5436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5437       };
5438     } catch (Dali::DaliException e) {
5439       {
5440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5441       };
5442     } catch (...) {
5443       {
5444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5445       };
5446     }
5447   }
5448
5449 }
5450
5451
5452 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_0(void * jarg1, void * jarg2) {
5453   void * jresult ;
5454   Dali::Vector2 *arg1 = 0 ;
5455   Dali::Vector2 *arg2 = 0 ;
5456   Dali::Vector2 result;
5457
5458   arg1 = (Dali::Vector2 *)jarg1;
5459   if (!arg1) {
5460     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5461     return 0;
5462   }
5463   arg2 = (Dali::Vector2 *)jarg2;
5464   if (!arg2) {
5465     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5466     return 0;
5467   }
5468   {
5469     try {
5470       result = Dali::Min((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
5471     } catch (std::out_of_range& e) {
5472       {
5473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5474       };
5475     } catch (std::exception& e) {
5476       {
5477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5478       };
5479     } catch (Dali::DaliException e) {
5480       {
5481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5482       };
5483     } catch (...) {
5484       {
5485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5486       };
5487     }
5488   }
5489
5490   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5491   return jresult;
5492 }
5493
5494
5495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_0(void * jarg1, void * jarg2) {
5496   void * jresult ;
5497   Dali::Vector2 *arg1 = 0 ;
5498   Dali::Vector2 *arg2 = 0 ;
5499   Dali::Vector2 result;
5500
5501   arg1 = (Dali::Vector2 *)jarg1;
5502   if (!arg1) {
5503     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5504     return 0;
5505   }
5506   arg2 = (Dali::Vector2 *)jarg2;
5507   if (!arg2) {
5508     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5509     return 0;
5510   }
5511   {
5512     try {
5513       result = Dali::Max((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
5514     } catch (std::out_of_range& e) {
5515       {
5516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5517       };
5518     } catch (std::exception& e) {
5519       {
5520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5521       };
5522     } catch (Dali::DaliException e) {
5523       {
5524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5525       };
5526     } catch (...) {
5527       {
5528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5529       };
5530     }
5531   }
5532
5533   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5534   return jresult;
5535 }
5536
5537
5538 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3) {
5539   void * jresult ;
5540   Dali::Vector2 *arg1 = 0 ;
5541   float *arg2 = 0 ;
5542   float *arg3 = 0 ;
5543   float temp2 ;
5544   float temp3 ;
5545   Dali::Vector2 result;
5546
5547   arg1 = (Dali::Vector2 *)jarg1;
5548   if (!arg1) {
5549     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5550     return 0;
5551   }
5552   temp2 = (float)jarg2;
5553   arg2 = &temp2;
5554   temp3 = (float)jarg3;
5555   arg3 = &temp3;
5556   {
5557     try {
5558       result = Dali::Clamp((Dali::Vector2 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
5559     } catch (std::out_of_range& e) {
5560       {
5561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5562       };
5563     } catch (std::exception& e) {
5564       {
5565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5566       };
5567     } catch (Dali::DaliException e) {
5568       {
5569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5570       };
5571     } catch (...) {
5572       {
5573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5574       };
5575     }
5576   }
5577
5578   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5579   return jresult;
5580 }
5581
5582
5583 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_0() {
5584   void * jresult ;
5585   Dali::Vector3 *result = 0 ;
5586
5587   {
5588     try {
5589       result = (Dali::Vector3 *)new Dali::Vector3();
5590     } catch (std::out_of_range& e) {
5591       {
5592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5593       };
5594     } catch (std::exception& e) {
5595       {
5596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5597       };
5598     } catch (Dali::DaliException e) {
5599       {
5600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5601       };
5602     } catch (...) {
5603       {
5604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5605       };
5606     }
5607   }
5608
5609   jresult = (void *)result;
5610   return jresult;
5611 }
5612
5613
5614 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_1(float jarg1, float jarg2, float jarg3) {
5615   void * jresult ;
5616   float arg1 ;
5617   float arg2 ;
5618   float arg3 ;
5619   Dali::Vector3 *result = 0 ;
5620
5621   arg1 = (float)jarg1;
5622   arg2 = (float)jarg2;
5623   arg3 = (float)jarg3;
5624   {
5625     try {
5626       result = (Dali::Vector3 *)new Dali::Vector3(arg1,arg2,arg3);
5627     } catch (std::out_of_range& e) {
5628       {
5629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5630       };
5631     } catch (std::exception& e) {
5632       {
5633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5634       };
5635     } catch (Dali::DaliException e) {
5636       {
5637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5638       };
5639     } catch (...) {
5640       {
5641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5642       };
5643     }
5644   }
5645
5646   jresult = (void *)result;
5647   return jresult;
5648 }
5649
5650
5651 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_2(float* jarg1) {
5652   void * jresult ;
5653   float *arg1 = (float *) 0 ;
5654   Dali::Vector3 *result = 0 ;
5655
5656   arg1 = jarg1;
5657   {
5658     try {
5659       result = (Dali::Vector3 *)new Dali::Vector3((float const *)arg1);
5660     } catch (std::out_of_range& e) {
5661       {
5662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5663       };
5664     } catch (std::exception& e) {
5665       {
5666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5667       };
5668     } catch (Dali::DaliException e) {
5669       {
5670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5671       };
5672     } catch (...) {
5673       {
5674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5675       };
5676     }
5677   }
5678
5679   jresult = (void *)result;
5680
5681
5682   return jresult;
5683 }
5684
5685
5686 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_3(void * jarg1) {
5687   void * jresult ;
5688   Dali::Vector2 *arg1 = 0 ;
5689   Dali::Vector3 *result = 0 ;
5690
5691   arg1 = (Dali::Vector2 *)jarg1;
5692   if (!arg1) {
5693     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5694     return 0;
5695   }
5696   {
5697     try {
5698       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector2 const &)*arg1);
5699     } catch (std::out_of_range& e) {
5700       {
5701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5702       };
5703     } catch (std::exception& e) {
5704       {
5705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5706       };
5707     } catch (Dali::DaliException e) {
5708       {
5709         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5710       };
5711     } catch (...) {
5712       {
5713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5714       };
5715     }
5716   }
5717
5718   jresult = (void *)result;
5719   return jresult;
5720 }
5721
5722
5723 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_4(void * jarg1) {
5724   void * jresult ;
5725   Dali::Vector4 *arg1 = 0 ;
5726   Dali::Vector3 *result = 0 ;
5727
5728   arg1 = (Dali::Vector4 *)jarg1;
5729   if (!arg1) {
5730     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5731     return 0;
5732   }
5733   {
5734     try {
5735       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector4 const &)*arg1);
5736     } catch (std::out_of_range& e) {
5737       {
5738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5739       };
5740     } catch (std::exception& e) {
5741       {
5742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5743       };
5744     } catch (Dali::DaliException e) {
5745       {
5746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5747       };
5748     } catch (...) {
5749       {
5750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5751       };
5752     }
5753   }
5754
5755   jresult = (void *)result;
5756   return jresult;
5757 }
5758
5759
5760 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ONE_get() {
5761   void * jresult ;
5762   Dali::Vector3 *result = 0 ;
5763
5764   result = (Dali::Vector3 *)&Dali::Vector3::ONE;
5765   jresult = (void *)result;
5766   return jresult;
5767 }
5768
5769
5770 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_XAXIS_get() {
5771   void * jresult ;
5772   Dali::Vector3 *result = 0 ;
5773
5774   result = (Dali::Vector3 *)&Dali::Vector3::XAXIS;
5775   jresult = (void *)result;
5776   return jresult;
5777 }
5778
5779
5780 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_YAXIS_get() {
5781   void * jresult ;
5782   Dali::Vector3 *result = 0 ;
5783
5784   result = (Dali::Vector3 *)&Dali::Vector3::YAXIS;
5785   jresult = (void *)result;
5786   return jresult;
5787 }
5788
5789
5790 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZAXIS_get() {
5791   void * jresult ;
5792   Dali::Vector3 *result = 0 ;
5793
5794   result = (Dali::Vector3 *)&Dali::Vector3::ZAXIS;
5795   jresult = (void *)result;
5796   return jresult;
5797 }
5798
5799
5800 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_XAXIS_get() {
5801   void * jresult ;
5802   Dali::Vector3 *result = 0 ;
5803
5804   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_XAXIS;
5805   jresult = (void *)result;
5806   return jresult;
5807 }
5808
5809
5810 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_YAXIS_get() {
5811   void * jresult ;
5812   Dali::Vector3 *result = 0 ;
5813
5814   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_YAXIS;
5815   jresult = (void *)result;
5816   return jresult;
5817 }
5818
5819
5820 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_ZAXIS_get() {
5821   void * jresult ;
5822   Dali::Vector3 *result = 0 ;
5823
5824   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_ZAXIS;
5825   jresult = (void *)result;
5826   return jresult;
5827 }
5828
5829
5830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZERO_get() {
5831   void * jresult ;
5832   Dali::Vector3 *result = 0 ;
5833
5834   result = (Dali::Vector3 *)&Dali::Vector3::ZERO;
5835   jresult = (void *)result;
5836   return jresult;
5837 }
5838
5839
5840 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_0(void * jarg1, float* jarg2) {
5841   void * jresult ;
5842   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5843   float *arg2 = (float *) 0 ;
5844   Dali::Vector3 *result = 0 ;
5845
5846   arg1 = (Dali::Vector3 *)jarg1;
5847   arg2 = jarg2;
5848   {
5849     try {
5850       result = (Dali::Vector3 *) &(arg1)->operator =((float const *)arg2);
5851     } catch (std::out_of_range& e) {
5852       {
5853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5854       };
5855     } catch (std::exception& e) {
5856       {
5857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5858       };
5859     } catch (Dali::DaliException e) {
5860       {
5861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5862       };
5863     } catch (...) {
5864       {
5865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5866       };
5867     }
5868   }
5869
5870   jresult = (void *)result;
5871
5872
5873   return jresult;
5874 }
5875
5876
5877 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_1(void * jarg1, void * jarg2) {
5878   void * jresult ;
5879   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5880   Dali::Vector2 *arg2 = 0 ;
5881   Dali::Vector3 *result = 0 ;
5882
5883   arg1 = (Dali::Vector3 *)jarg1;
5884   arg2 = (Dali::Vector2 *)jarg2;
5885   if (!arg2) {
5886     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5887     return 0;
5888   }
5889   {
5890     try {
5891       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
5892     } catch (std::out_of_range& e) {
5893       {
5894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5895       };
5896     } catch (std::exception& e) {
5897       {
5898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5899       };
5900     } catch (Dali::DaliException e) {
5901       {
5902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5903       };
5904     } catch (...) {
5905       {
5906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5907       };
5908     }
5909   }
5910
5911   jresult = (void *)result;
5912   return jresult;
5913 }
5914
5915
5916 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_2(void * jarg1, void * jarg2) {
5917   void * jresult ;
5918   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5919   Dali::Vector4 *arg2 = 0 ;
5920   Dali::Vector3 *result = 0 ;
5921
5922   arg1 = (Dali::Vector3 *)jarg1;
5923   arg2 = (Dali::Vector4 *)jarg2;
5924   if (!arg2) {
5925     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5926     return 0;
5927   }
5928   {
5929     try {
5930       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
5931     } catch (std::out_of_range& e) {
5932       {
5933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5934       };
5935     } catch (std::exception& e) {
5936       {
5937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5938       };
5939     } catch (Dali::DaliException e) {
5940       {
5941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5942       };
5943     } catch (...) {
5944       {
5945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5946       };
5947     }
5948   }
5949
5950   jresult = (void *)result;
5951   return jresult;
5952 }
5953
5954
5955 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Add(void * jarg1, void * jarg2) {
5956   void * jresult ;
5957   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5958   Dali::Vector3 *arg2 = 0 ;
5959   Dali::Vector3 result;
5960
5961   arg1 = (Dali::Vector3 *)jarg1;
5962   arg2 = (Dali::Vector3 *)jarg2;
5963   if (!arg2) {
5964     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5965     return 0;
5966   }
5967   {
5968     try {
5969       result = ((Dali::Vector3 const *)arg1)->operator +((Dali::Vector3 const &)*arg2);
5970     } catch (std::out_of_range& e) {
5971       {
5972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5973       };
5974     } catch (std::exception& e) {
5975       {
5976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5977       };
5978     } catch (Dali::DaliException e) {
5979       {
5980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5981       };
5982     } catch (...) {
5983       {
5984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5985       };
5986     }
5987   }
5988
5989   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5990   return jresult;
5991 }
5992
5993
5994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AddAssign(void * jarg1, void * jarg2) {
5995   void * jresult ;
5996   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5997   Dali::Vector3 *arg2 = 0 ;
5998   Dali::Vector3 *result = 0 ;
5999
6000   arg1 = (Dali::Vector3 *)jarg1;
6001   arg2 = (Dali::Vector3 *)jarg2;
6002   if (!arg2) {
6003     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6004     return 0;
6005   }
6006   {
6007     try {
6008       result = (Dali::Vector3 *) &(arg1)->operator +=((Dali::Vector3 const &)*arg2);
6009     } catch (std::out_of_range& e) {
6010       {
6011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6012       };
6013     } catch (std::exception& e) {
6014       {
6015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6016       };
6017     } catch (Dali::DaliException e) {
6018       {
6019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6020       };
6021     } catch (...) {
6022       {
6023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6024       };
6025     }
6026   }
6027
6028   jresult = (void *)result;
6029   return jresult;
6030 }
6031
6032
6033 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_0(void * jarg1, void * jarg2) {
6034   void * jresult ;
6035   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6036   Dali::Vector3 *arg2 = 0 ;
6037   Dali::Vector3 result;
6038
6039   arg1 = (Dali::Vector3 *)jarg1;
6040   arg2 = (Dali::Vector3 *)jarg2;
6041   if (!arg2) {
6042     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6043     return 0;
6044   }
6045   {
6046     try {
6047       result = ((Dali::Vector3 const *)arg1)->operator -((Dali::Vector3 const &)*arg2);
6048     } catch (std::out_of_range& e) {
6049       {
6050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6051       };
6052     } catch (std::exception& e) {
6053       {
6054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6055       };
6056     } catch (Dali::DaliException e) {
6057       {
6058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6059       };
6060     } catch (...) {
6061       {
6062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6063       };
6064     }
6065   }
6066
6067   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6068   return jresult;
6069 }
6070
6071
6072 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_SubtractAssign(void * jarg1, void * jarg2) {
6073   void * jresult ;
6074   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6075   Dali::Vector3 *arg2 = 0 ;
6076   Dali::Vector3 *result = 0 ;
6077
6078   arg1 = (Dali::Vector3 *)jarg1;
6079   arg2 = (Dali::Vector3 *)jarg2;
6080   if (!arg2) {
6081     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6082     return 0;
6083   }
6084   {
6085     try {
6086       result = (Dali::Vector3 *) &(arg1)->operator -=((Dali::Vector3 const &)*arg2);
6087     } catch (std::out_of_range& e) {
6088       {
6089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6090       };
6091     } catch (std::exception& e) {
6092       {
6093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6094       };
6095     } catch (Dali::DaliException e) {
6096       {
6097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6098       };
6099     } catch (...) {
6100       {
6101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6102       };
6103     }
6104   }
6105
6106   jresult = (void *)result;
6107   return jresult;
6108 }
6109
6110
6111 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_0(void * jarg1, void * jarg2) {
6112   void * jresult ;
6113   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6114   Dali::Vector3 *arg2 = 0 ;
6115   Dali::Vector3 result;
6116
6117   arg1 = (Dali::Vector3 *)jarg1;
6118   arg2 = (Dali::Vector3 *)jarg2;
6119   if (!arg2) {
6120     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6121     return 0;
6122   }
6123   {
6124     try {
6125       result = ((Dali::Vector3 const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
6126     } catch (std::out_of_range& e) {
6127       {
6128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6129       };
6130     } catch (std::exception& e) {
6131       {
6132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6133       };
6134     } catch (Dali::DaliException e) {
6135       {
6136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6137       };
6138     } catch (...) {
6139       {
6140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6141       };
6142     }
6143   }
6144
6145   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6146   return jresult;
6147 }
6148
6149
6150 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_1(void * jarg1, float jarg2) {
6151   void * jresult ;
6152   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6153   float arg2 ;
6154   Dali::Vector3 result;
6155
6156   arg1 = (Dali::Vector3 *)jarg1;
6157   arg2 = (float)jarg2;
6158   {
6159     try {
6160       result = ((Dali::Vector3 const *)arg1)->operator *(arg2);
6161     } catch (std::out_of_range& e) {
6162       {
6163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6164       };
6165     } catch (std::exception& e) {
6166       {
6167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6168       };
6169     } catch (Dali::DaliException e) {
6170       {
6171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6172       };
6173     } catch (...) {
6174       {
6175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6176       };
6177     }
6178   }
6179
6180   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6181   return jresult;
6182 }
6183
6184
6185 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
6186   void * jresult ;
6187   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6188   Dali::Vector3 *arg2 = 0 ;
6189   Dali::Vector3 *result = 0 ;
6190
6191   arg1 = (Dali::Vector3 *)jarg1;
6192   arg2 = (Dali::Vector3 *)jarg2;
6193   if (!arg2) {
6194     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6195     return 0;
6196   }
6197   {
6198     try {
6199       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Vector3 const &)*arg2);
6200     } catch (std::out_of_range& e) {
6201       {
6202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6203       };
6204     } catch (std::exception& e) {
6205       {
6206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6207       };
6208     } catch (Dali::DaliException e) {
6209       {
6210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6211       };
6212     } catch (...) {
6213       {
6214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6215       };
6216     }
6217   }
6218
6219   jresult = (void *)result;
6220   return jresult;
6221 }
6222
6223
6224 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
6225   void * jresult ;
6226   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6227   float arg2 ;
6228   Dali::Vector3 *result = 0 ;
6229
6230   arg1 = (Dali::Vector3 *)jarg1;
6231   arg2 = (float)jarg2;
6232   {
6233     try {
6234       result = (Dali::Vector3 *) &(arg1)->operator *=(arg2);
6235     } catch (std::out_of_range& e) {
6236       {
6237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6238       };
6239     } catch (std::exception& e) {
6240       {
6241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6242       };
6243     } catch (Dali::DaliException e) {
6244       {
6245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6246       };
6247     } catch (...) {
6248       {
6249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6250       };
6251     }
6252   }
6253
6254   jresult = (void *)result;
6255   return jresult;
6256 }
6257
6258
6259 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_2(void * jarg1, void * jarg2) {
6260   void * jresult ;
6261   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6262   Dali::Quaternion *arg2 = 0 ;
6263   Dali::Vector3 *result = 0 ;
6264
6265   arg1 = (Dali::Vector3 *)jarg1;
6266   arg2 = (Dali::Quaternion *)jarg2;
6267   if (!arg2) {
6268     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
6269     return 0;
6270   }
6271   {
6272     try {
6273       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
6274     } catch (std::out_of_range& e) {
6275       {
6276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6277       };
6278     } catch (std::exception& e) {
6279       {
6280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6281       };
6282     } catch (Dali::DaliException e) {
6283       {
6284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6285       };
6286     } catch (...) {
6287       {
6288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6289       };
6290     }
6291   }
6292
6293   jresult = (void *)result;
6294   return jresult;
6295 }
6296
6297
6298 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_0(void * jarg1, void * jarg2) {
6299   void * jresult ;
6300   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6301   Dali::Vector3 *arg2 = 0 ;
6302   Dali::Vector3 result;
6303
6304   arg1 = (Dali::Vector3 *)jarg1;
6305   arg2 = (Dali::Vector3 *)jarg2;
6306   if (!arg2) {
6307     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6308     return 0;
6309   }
6310   {
6311     try {
6312       result = ((Dali::Vector3 const *)arg1)->operator /((Dali::Vector3 const &)*arg2);
6313     } catch (std::out_of_range& e) {
6314       {
6315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6316       };
6317     } catch (std::exception& e) {
6318       {
6319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6320       };
6321     } catch (Dali::DaliException e) {
6322       {
6323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6324       };
6325     } catch (...) {
6326       {
6327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6328       };
6329     }
6330   }
6331
6332   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6333   return jresult;
6334 }
6335
6336
6337 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_1(void * jarg1, float jarg2) {
6338   void * jresult ;
6339   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6340   float arg2 ;
6341   Dali::Vector3 result;
6342
6343   arg1 = (Dali::Vector3 *)jarg1;
6344   arg2 = (float)jarg2;
6345   {
6346     try {
6347       result = ((Dali::Vector3 const *)arg1)->operator /(arg2);
6348     } catch (std::out_of_range& e) {
6349       {
6350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6351       };
6352     } catch (std::exception& e) {
6353       {
6354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6355       };
6356     } catch (Dali::DaliException e) {
6357       {
6358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6359       };
6360     } catch (...) {
6361       {
6362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6363       };
6364     }
6365   }
6366
6367   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6368   return jresult;
6369 }
6370
6371
6372 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
6373   void * jresult ;
6374   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6375   Dali::Vector3 *arg2 = 0 ;
6376   Dali::Vector3 *result = 0 ;
6377
6378   arg1 = (Dali::Vector3 *)jarg1;
6379   arg2 = (Dali::Vector3 *)jarg2;
6380   if (!arg2) {
6381     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6382     return 0;
6383   }
6384   {
6385     try {
6386       result = (Dali::Vector3 *) &(arg1)->operator /=((Dali::Vector3 const &)*arg2);
6387     } catch (std::out_of_range& e) {
6388       {
6389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6390       };
6391     } catch (std::exception& e) {
6392       {
6393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6394       };
6395     } catch (Dali::DaliException e) {
6396       {
6397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6398       };
6399     } catch (...) {
6400       {
6401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6402       };
6403     }
6404   }
6405
6406   jresult = (void *)result;
6407   return jresult;
6408 }
6409
6410
6411 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
6412   void * jresult ;
6413   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6414   float arg2 ;
6415   Dali::Vector3 *result = 0 ;
6416
6417   arg1 = (Dali::Vector3 *)jarg1;
6418   arg2 = (float)jarg2;
6419   {
6420     try {
6421       result = (Dali::Vector3 *) &(arg1)->operator /=(arg2);
6422     } catch (std::out_of_range& e) {
6423       {
6424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6425       };
6426     } catch (std::exception& e) {
6427       {
6428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6429       };
6430     } catch (Dali::DaliException e) {
6431       {
6432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6433       };
6434     } catch (...) {
6435       {
6436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6437       };
6438     }
6439   }
6440
6441   jresult = (void *)result;
6442   return jresult;
6443 }
6444
6445
6446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_1(void * jarg1) {
6447   void * jresult ;
6448   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6449   Dali::Vector3 result;
6450
6451   arg1 = (Dali::Vector3 *)jarg1;
6452   {
6453     try {
6454       result = ((Dali::Vector3 const *)arg1)->operator -();
6455     } catch (std::out_of_range& e) {
6456       {
6457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6458       };
6459     } catch (std::exception& e) {
6460       {
6461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6462       };
6463     } catch (Dali::DaliException e) {
6464       {
6465         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6466       };
6467     } catch (...) {
6468       {
6469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6470       };
6471     }
6472   }
6473
6474   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6475   return jresult;
6476 }
6477
6478
6479 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_EqualTo(void * jarg1, void * jarg2) {
6480   unsigned int jresult ;
6481   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6482   Dali::Vector3 *arg2 = 0 ;
6483   bool result;
6484
6485   arg1 = (Dali::Vector3 *)jarg1;
6486   arg2 = (Dali::Vector3 *)jarg2;
6487   if (!arg2) {
6488     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6489     return 0;
6490   }
6491   {
6492     try {
6493       result = (bool)((Dali::Vector3 const *)arg1)->operator ==((Dali::Vector3 const &)*arg2);
6494     } catch (std::out_of_range& e) {
6495       {
6496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6497       };
6498     } catch (std::exception& e) {
6499       {
6500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6501       };
6502     } catch (Dali::DaliException e) {
6503       {
6504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6505       };
6506     } catch (...) {
6507       {
6508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6509       };
6510     }
6511   }
6512
6513   jresult = result;
6514   return jresult;
6515 }
6516
6517
6518 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_NotEqualTo(void * jarg1, void * jarg2) {
6519   unsigned int jresult ;
6520   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6521   Dali::Vector3 *arg2 = 0 ;
6522   bool result;
6523
6524   arg1 = (Dali::Vector3 *)jarg1;
6525   arg2 = (Dali::Vector3 *)jarg2;
6526   if (!arg2) {
6527     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6528     return 0;
6529   }
6530   {
6531     try {
6532       result = (bool)((Dali::Vector3 const *)arg1)->operator !=((Dali::Vector3 const &)*arg2);
6533     } catch (std::out_of_range& e) {
6534       {
6535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6536       };
6537     } catch (std::exception& e) {
6538       {
6539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6540       };
6541     } catch (Dali::DaliException e) {
6542       {
6543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6544       };
6545     } catch (...) {
6546       {
6547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6548       };
6549     }
6550   }
6551
6552   jresult = result;
6553   return jresult;
6554 }
6555
6556
6557 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
6558   float jresult ;
6559   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6560   unsigned int arg2 ;
6561   float *result = 0 ;
6562
6563   arg1 = (Dali::Vector3 *)jarg1;
6564   arg2 = (unsigned int)jarg2;
6565   {
6566     try {
6567       result = (float *) &((Dali::Vector3 const *)arg1)->operator [](arg2);
6568     } catch (std::out_of_range& e) {
6569       {
6570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6571       };
6572     } catch (std::exception& e) {
6573       {
6574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6575       };
6576     } catch (Dali::DaliException e) {
6577       {
6578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6579       };
6580     } catch (...) {
6581       {
6582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6583       };
6584     }
6585   }
6586
6587   jresult = *result;
6588   return jresult;
6589 }
6590
6591
6592 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Dot(void * jarg1, void * jarg2) {
6593   float jresult ;
6594   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6595   Dali::Vector3 *arg2 = 0 ;
6596   float result;
6597
6598   arg1 = (Dali::Vector3 *)jarg1;
6599   arg2 = (Dali::Vector3 *)jarg2;
6600   if (!arg2) {
6601     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6602     return 0;
6603   }
6604   {
6605     try {
6606       result = (float)((Dali::Vector3 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
6607     } catch (std::out_of_range& e) {
6608       {
6609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6610       };
6611     } catch (std::exception& e) {
6612       {
6613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6614       };
6615     } catch (Dali::DaliException e) {
6616       {
6617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6618       };
6619     } catch (...) {
6620       {
6621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6622       };
6623     }
6624   }
6625
6626   jresult = result;
6627   return jresult;
6628 }
6629
6630
6631 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Cross(void * jarg1, void * jarg2) {
6632   void * jresult ;
6633   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6634   Dali::Vector3 *arg2 = 0 ;
6635   Dali::Vector3 result;
6636
6637   arg1 = (Dali::Vector3 *)jarg1;
6638   arg2 = (Dali::Vector3 *)jarg2;
6639   if (!arg2) {
6640     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6641     return 0;
6642   }
6643   {
6644     try {
6645       result = ((Dali::Vector3 const *)arg1)->Cross((Dali::Vector3 const &)*arg2);
6646     } catch (std::out_of_range& e) {
6647       {
6648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6649       };
6650     } catch (std::exception& e) {
6651       {
6652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6653       };
6654     } catch (Dali::DaliException e) {
6655       {
6656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6657       };
6658     } catch (...) {
6659       {
6660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6661       };
6662     }
6663   }
6664
6665   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6666   return jresult;
6667 }
6668
6669
6670 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Length(void * jarg1) {
6671   float jresult ;
6672   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6673   float result;
6674
6675   arg1 = (Dali::Vector3 *)jarg1;
6676   {
6677     try {
6678       result = (float)((Dali::Vector3 const *)arg1)->Length();
6679     } catch (std::out_of_range& e) {
6680       {
6681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6682       };
6683     } catch (std::exception& e) {
6684       {
6685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6686       };
6687     } catch (Dali::DaliException e) {
6688       {
6689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6690       };
6691     } catch (...) {
6692       {
6693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6694       };
6695     }
6696   }
6697
6698   jresult = result;
6699   return jresult;
6700 }
6701
6702
6703 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_LengthSquared(void * jarg1) {
6704   float jresult ;
6705   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6706   float result;
6707
6708   arg1 = (Dali::Vector3 *)jarg1;
6709   {
6710     try {
6711       result = (float)((Dali::Vector3 const *)arg1)->LengthSquared();
6712     } catch (std::out_of_range& e) {
6713       {
6714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6715       };
6716     } catch (std::exception& e) {
6717       {
6718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6719       };
6720     } catch (Dali::DaliException e) {
6721       {
6722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6723       };
6724     } catch (...) {
6725       {
6726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6727       };
6728     }
6729   }
6730
6731   jresult = result;
6732   return jresult;
6733 }
6734
6735
6736 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Normalize(void * jarg1) {
6737   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6738
6739   arg1 = (Dali::Vector3 *)jarg1;
6740   {
6741     try {
6742       (arg1)->Normalize();
6743     } catch (std::out_of_range& e) {
6744       {
6745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6746       };
6747     } catch (std::exception& e) {
6748       {
6749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6750       };
6751     } catch (Dali::DaliException e) {
6752       {
6753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
6754       };
6755     } catch (...) {
6756       {
6757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6758       };
6759     }
6760   }
6761
6762 }
6763
6764
6765 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Clamp(void * jarg1, void * jarg2, void * jarg3) {
6766   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6767   Dali::Vector3 *arg2 = 0 ;
6768   Dali::Vector3 *arg3 = 0 ;
6769
6770   arg1 = (Dali::Vector3 *)jarg1;
6771   arg2 = (Dali::Vector3 *)jarg2;
6772   if (!arg2) {
6773     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6774     return ;
6775   }
6776   arg3 = (Dali::Vector3 *)jarg3;
6777   if (!arg3) {
6778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6779     return ;
6780   }
6781   {
6782     try {
6783       (arg1)->Clamp((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3);
6784     } catch (std::out_of_range& e) {
6785       {
6786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6787       };
6788     } catch (std::exception& e) {
6789       {
6790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6791       };
6792     } catch (Dali::DaliException e) {
6793       {
6794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
6795       };
6796     } catch (...) {
6797       {
6798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6799       };
6800     }
6801   }
6802
6803 }
6804
6805
6806 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AsFloat__SWIG_0(void * jarg1) {
6807   void * jresult ;
6808   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6809   float *result = 0 ;
6810
6811   arg1 = (Dali::Vector3 *)jarg1;
6812   {
6813     try {
6814       result = (float *)((Dali::Vector3 const *)arg1)->AsFloat();
6815     } catch (std::out_of_range& e) {
6816       {
6817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6818       };
6819     } catch (std::exception& e) {
6820       {
6821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6822       };
6823     } catch (Dali::DaliException e) {
6824       {
6825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6826       };
6827     } catch (...) {
6828       {
6829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6830       };
6831     }
6832   }
6833
6834   jresult = (void *)result;
6835   return jresult;
6836 }
6837
6838
6839 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorXY__SWIG_0(void * jarg1) {
6840   void * jresult ;
6841   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6842   Dali::Vector2 *result = 0 ;
6843
6844   arg1 = (Dali::Vector3 *)jarg1;
6845   {
6846     try {
6847       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorXY();
6848     } catch (std::out_of_range& e) {
6849       {
6850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6851       };
6852     } catch (std::exception& e) {
6853       {
6854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6855       };
6856     } catch (Dali::DaliException e) {
6857       {
6858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6859       };
6860     } catch (...) {
6861       {
6862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6863       };
6864     }
6865   }
6866
6867   jresult = (void *)result;
6868   return jresult;
6869 }
6870
6871
6872 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorYZ__SWIG_0(void * jarg1) {
6873   void * jresult ;
6874   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6875   Dali::Vector2 *result = 0 ;
6876
6877   arg1 = (Dali::Vector3 *)jarg1;
6878   {
6879     try {
6880       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorYZ();
6881     } catch (std::out_of_range& e) {
6882       {
6883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6884       };
6885     } catch (std::exception& e) {
6886       {
6887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6888       };
6889     } catch (Dali::DaliException e) {
6890       {
6891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6892       };
6893     } catch (...) {
6894       {
6895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6896       };
6897     }
6898   }
6899
6900   jresult = (void *)result;
6901   return jresult;
6902 }
6903
6904
6905 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_X_set(void * jarg1, float jarg2) {
6906   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6907   float arg2 ;
6908
6909   arg1 = (Dali::Vector3 *)jarg1;
6910   arg2 = (float)jarg2;
6911   if (arg1) (arg1)->x = arg2;
6912 }
6913
6914
6915 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_X_get(void * jarg1) {
6916   float jresult ;
6917   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6918   float result;
6919
6920   arg1 = (Dali::Vector3 *)jarg1;
6921   result = (float) ((arg1)->x);
6922   jresult = result;
6923   return jresult;
6924 }
6925
6926
6927 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Width_set(void * jarg1, float jarg2) {
6928   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6929   float arg2 ;
6930
6931   arg1 = (Dali::Vector3 *)jarg1;
6932   arg2 = (float)jarg2;
6933   if (arg1) (arg1)->width = arg2;
6934 }
6935
6936
6937 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Width_get(void * jarg1) {
6938   float jresult ;
6939   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6940   float result;
6941
6942   arg1 = (Dali::Vector3 *)jarg1;
6943   result = (float) ((arg1)->width);
6944   jresult = result;
6945   return jresult;
6946 }
6947
6948
6949 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_r_set(void * jarg1, float jarg2) {
6950   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6951   float arg2 ;
6952
6953   arg1 = (Dali::Vector3 *)jarg1;
6954   arg2 = (float)jarg2;
6955   if (arg1) (arg1)->r = arg2;
6956 }
6957
6958
6959 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_r_get(void * jarg1) {
6960   float jresult ;
6961   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6962   float result;
6963
6964   arg1 = (Dali::Vector3 *)jarg1;
6965   result = (float) ((arg1)->r);
6966   jresult = result;
6967   return jresult;
6968 }
6969
6970
6971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Y_set(void * jarg1, float jarg2) {
6972   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6973   float arg2 ;
6974
6975   arg1 = (Dali::Vector3 *)jarg1;
6976   arg2 = (float)jarg2;
6977   if (arg1) (arg1)->y = arg2;
6978 }
6979
6980
6981 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Y_get(void * jarg1) {
6982   float jresult ;
6983   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6984   float result;
6985
6986   arg1 = (Dali::Vector3 *)jarg1;
6987   result = (float) ((arg1)->y);
6988   jresult = result;
6989   return jresult;
6990 }
6991
6992
6993 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Height_set(void * jarg1, float jarg2) {
6994   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6995   float arg2 ;
6996
6997   arg1 = (Dali::Vector3 *)jarg1;
6998   arg2 = (float)jarg2;
6999   if (arg1) (arg1)->height = arg2;
7000 }
7001
7002
7003 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Height_get(void * jarg1) {
7004   float jresult ;
7005   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7006   float result;
7007
7008   arg1 = (Dali::Vector3 *)jarg1;
7009   result = (float) ((arg1)->height);
7010   jresult = result;
7011   return jresult;
7012 }
7013
7014
7015 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_g_set(void * jarg1, float jarg2) {
7016   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7017   float arg2 ;
7018
7019   arg1 = (Dali::Vector3 *)jarg1;
7020   arg2 = (float)jarg2;
7021   if (arg1) (arg1)->g = arg2;
7022 }
7023
7024
7025 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_g_get(void * jarg1) {
7026   float jresult ;
7027   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7028   float result;
7029
7030   arg1 = (Dali::Vector3 *)jarg1;
7031   result = (float) ((arg1)->g);
7032   jresult = result;
7033   return jresult;
7034 }
7035
7036
7037 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Z_set(void * jarg1, float jarg2) {
7038   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7039   float arg2 ;
7040
7041   arg1 = (Dali::Vector3 *)jarg1;
7042   arg2 = (float)jarg2;
7043   if (arg1) (arg1)->z = arg2;
7044 }
7045
7046
7047 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Z_get(void * jarg1) {
7048   float jresult ;
7049   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7050   float result;
7051
7052   arg1 = (Dali::Vector3 *)jarg1;
7053   result = (float) ((arg1)->z);
7054   jresult = result;
7055   return jresult;
7056 }
7057
7058
7059 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Depth_set(void * jarg1, float jarg2) {
7060   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7061   float arg2 ;
7062
7063   arg1 = (Dali::Vector3 *)jarg1;
7064   arg2 = (float)jarg2;
7065   if (arg1) (arg1)->depth = arg2;
7066 }
7067
7068
7069 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Depth_get(void * jarg1) {
7070   float jresult ;
7071   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7072   float result;
7073
7074   arg1 = (Dali::Vector3 *)jarg1;
7075   result = (float) ((arg1)->depth);
7076   jresult = result;
7077   return jresult;
7078 }
7079
7080
7081 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_b_set(void * jarg1, float jarg2) {
7082   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7083   float arg2 ;
7084
7085   arg1 = (Dali::Vector3 *)jarg1;
7086   arg2 = (float)jarg2;
7087   if (arg1) (arg1)->b = arg2;
7088 }
7089
7090
7091 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_b_get(void * jarg1) {
7092   float jresult ;
7093   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7094   float result;
7095
7096   arg1 = (Dali::Vector3 *)jarg1;
7097   result = (float) ((arg1)->b);
7098   jresult = result;
7099   return jresult;
7100 }
7101
7102
7103 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector3(void * jarg1) {
7104   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7105
7106   arg1 = (Dali::Vector3 *)jarg1;
7107   {
7108     try {
7109       delete arg1;
7110     } catch (std::out_of_range& e) {
7111       {
7112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7113       };
7114     } catch (std::exception& e) {
7115       {
7116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7117       };
7118     } catch (Dali::DaliException e) {
7119       {
7120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
7121       };
7122     } catch (...) {
7123       {
7124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7125       };
7126     }
7127   }
7128
7129 }
7130
7131
7132 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_1(void * jarg1, void * jarg2) {
7133   void * jresult ;
7134   Dali::Vector3 *arg1 = 0 ;
7135   Dali::Vector3 *arg2 = 0 ;
7136   Dali::Vector3 result;
7137
7138   arg1 = (Dali::Vector3 *)jarg1;
7139   if (!arg1) {
7140     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7141     return 0;
7142   }
7143   arg2 = (Dali::Vector3 *)jarg2;
7144   if (!arg2) {
7145     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7146     return 0;
7147   }
7148   {
7149     try {
7150       result = Dali::Min((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
7151     } catch (std::out_of_range& e) {
7152       {
7153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7154       };
7155     } catch (std::exception& e) {
7156       {
7157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7158       };
7159     } catch (Dali::DaliException e) {
7160       {
7161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7162       };
7163     } catch (...) {
7164       {
7165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7166       };
7167     }
7168   }
7169
7170   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7171   return jresult;
7172 }
7173
7174
7175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_1(void * jarg1, void * jarg2) {
7176   void * jresult ;
7177   Dali::Vector3 *arg1 = 0 ;
7178   Dali::Vector3 *arg2 = 0 ;
7179   Dali::Vector3 result;
7180
7181   arg1 = (Dali::Vector3 *)jarg1;
7182   if (!arg1) {
7183     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7184     return 0;
7185   }
7186   arg2 = (Dali::Vector3 *)jarg2;
7187   if (!arg2) {
7188     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7189     return 0;
7190   }
7191   {
7192     try {
7193       result = Dali::Max((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
7194     } catch (std::out_of_range& e) {
7195       {
7196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7197       };
7198     } catch (std::exception& e) {
7199       {
7200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7201       };
7202     } catch (Dali::DaliException e) {
7203       {
7204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7205       };
7206     } catch (...) {
7207       {
7208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7209       };
7210     }
7211   }
7212
7213   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7214   return jresult;
7215 }
7216
7217
7218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
7219   void * jresult ;
7220   Dali::Vector3 *arg1 = 0 ;
7221   float *arg2 = 0 ;
7222   float *arg3 = 0 ;
7223   float temp2 ;
7224   float temp3 ;
7225   Dali::Vector3 result;
7226
7227   arg1 = (Dali::Vector3 *)jarg1;
7228   if (!arg1) {
7229     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7230     return 0;
7231   }
7232   temp2 = (float)jarg2;
7233   arg2 = &temp2;
7234   temp3 = (float)jarg3;
7235   arg3 = &temp3;
7236   {
7237     try {
7238       result = Dali::Clamp((Dali::Vector3 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
7239     } catch (std::out_of_range& e) {
7240       {
7241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7242       };
7243     } catch (std::exception& e) {
7244       {
7245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7246       };
7247     } catch (Dali::DaliException e) {
7248       {
7249         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7250       };
7251     } catch (...) {
7252       {
7253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7254       };
7255     }
7256   }
7257
7258   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7259   return jresult;
7260 }
7261
7262
7263 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_0() {
7264   void * jresult ;
7265   Dali::Vector4 *result = 0 ;
7266
7267   {
7268     try {
7269       result = (Dali::Vector4 *)new Dali::Vector4();
7270     } catch (std::out_of_range& e) {
7271       {
7272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7273       };
7274     } catch (std::exception& e) {
7275       {
7276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7277       };
7278     } catch (Dali::DaliException e) {
7279       {
7280         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7281       };
7282     } catch (...) {
7283       {
7284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7285       };
7286     }
7287   }
7288
7289   jresult = (void *)result;
7290   return jresult;
7291 }
7292
7293
7294 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
7295   void * jresult ;
7296   float arg1 ;
7297   float arg2 ;
7298   float arg3 ;
7299   float arg4 ;
7300   Dali::Vector4 *result = 0 ;
7301
7302   arg1 = (float)jarg1;
7303   arg2 = (float)jarg2;
7304   arg3 = (float)jarg3;
7305   arg4 = (float)jarg4;
7306   {
7307     try {
7308       result = (Dali::Vector4 *)new Dali::Vector4(arg1,arg2,arg3,arg4);
7309     } catch (std::out_of_range& e) {
7310       {
7311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7312       };
7313     } catch (std::exception& e) {
7314       {
7315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7316       };
7317     } catch (Dali::DaliException e) {
7318       {
7319         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7320       };
7321     } catch (...) {
7322       {
7323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7324       };
7325     }
7326   }
7327
7328   jresult = (void *)result;
7329   return jresult;
7330 }
7331
7332
7333 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_2(float* jarg1) {
7334   void * jresult ;
7335   float *arg1 = (float *) 0 ;
7336   Dali::Vector4 *result = 0 ;
7337
7338   arg1 = jarg1;
7339   {
7340     try {
7341       result = (Dali::Vector4 *)new Dali::Vector4((float const *)arg1);
7342     } catch (std::out_of_range& e) {
7343       {
7344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7345       };
7346     } catch (std::exception& e) {
7347       {
7348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7349       };
7350     } catch (Dali::DaliException e) {
7351       {
7352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7353       };
7354     } catch (...) {
7355       {
7356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7357       };
7358     }
7359   }
7360
7361   jresult = (void *)result;
7362
7363
7364   return jresult;
7365 }
7366
7367
7368 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_3(void * jarg1) {
7369   void * jresult ;
7370   Dali::Vector2 *arg1 = 0 ;
7371   Dali::Vector4 *result = 0 ;
7372
7373   arg1 = (Dali::Vector2 *)jarg1;
7374   if (!arg1) {
7375     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
7376     return 0;
7377   }
7378   {
7379     try {
7380       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector2 const &)*arg1);
7381     } catch (std::out_of_range& e) {
7382       {
7383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7384       };
7385     } catch (std::exception& e) {
7386       {
7387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7388       };
7389     } catch (Dali::DaliException e) {
7390       {
7391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7392       };
7393     } catch (...) {
7394       {
7395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7396       };
7397     }
7398   }
7399
7400   jresult = (void *)result;
7401   return jresult;
7402 }
7403
7404
7405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_4(void * jarg1) {
7406   void * jresult ;
7407   Dali::Vector3 *arg1 = 0 ;
7408   Dali::Vector4 *result = 0 ;
7409
7410   arg1 = (Dali::Vector3 *)jarg1;
7411   if (!arg1) {
7412     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7413     return 0;
7414   }
7415   {
7416     try {
7417       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector3 const &)*arg1);
7418     } catch (std::out_of_range& e) {
7419       {
7420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7421       };
7422     } catch (std::exception& e) {
7423       {
7424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7425       };
7426     } catch (Dali::DaliException e) {
7427       {
7428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7429       };
7430     } catch (...) {
7431       {
7432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7433       };
7434     }
7435   }
7436
7437   jresult = (void *)result;
7438   return jresult;
7439 }
7440
7441
7442 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ONE_get() {
7443   void * jresult ;
7444   Dali::Vector4 *result = 0 ;
7445
7446   result = (Dali::Vector4 *)&Dali::Vector4::ONE;
7447   jresult = (void *)result;
7448   return jresult;
7449 }
7450
7451
7452 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_XAXIS_get() {
7453   void * jresult ;
7454   Dali::Vector4 *result = 0 ;
7455
7456   result = (Dali::Vector4 *)&Dali::Vector4::XAXIS;
7457   jresult = (void *)result;
7458   return jresult;
7459 }
7460
7461
7462 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_YAXIS_get() {
7463   void * jresult ;
7464   Dali::Vector4 *result = 0 ;
7465
7466   result = (Dali::Vector4 *)&Dali::Vector4::YAXIS;
7467   jresult = (void *)result;
7468   return jresult;
7469 }
7470
7471
7472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZAXIS_get() {
7473   void * jresult ;
7474   Dali::Vector4 *result = 0 ;
7475
7476   result = (Dali::Vector4 *)&Dali::Vector4::ZAXIS;
7477   jresult = (void *)result;
7478   return jresult;
7479 }
7480
7481
7482 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZERO_get() {
7483   void * jresult ;
7484   Dali::Vector4 *result = 0 ;
7485
7486   result = (Dali::Vector4 *)&Dali::Vector4::ZERO;
7487   jresult = (void *)result;
7488   return jresult;
7489 }
7490
7491
7492 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_0(void * jarg1, float* jarg2) {
7493   void * jresult ;
7494   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7495   float *arg2 = (float *) 0 ;
7496   Dali::Vector4 *result = 0 ;
7497
7498   arg1 = (Dali::Vector4 *)jarg1;
7499   arg2 = jarg2;
7500   {
7501     try {
7502       result = (Dali::Vector4 *) &(arg1)->operator =((float const *)arg2);
7503     } catch (std::out_of_range& e) {
7504       {
7505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7506       };
7507     } catch (std::exception& e) {
7508       {
7509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7510       };
7511     } catch (Dali::DaliException e) {
7512       {
7513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7514       };
7515     } catch (...) {
7516       {
7517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7518       };
7519     }
7520   }
7521
7522   jresult = (void *)result;
7523
7524
7525   return jresult;
7526 }
7527
7528
7529 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_1(void * jarg1, void * jarg2) {
7530   void * jresult ;
7531   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7532   Dali::Vector2 *arg2 = 0 ;
7533   Dali::Vector4 *result = 0 ;
7534
7535   arg1 = (Dali::Vector4 *)jarg1;
7536   arg2 = (Dali::Vector2 *)jarg2;
7537   if (!arg2) {
7538     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
7539     return 0;
7540   }
7541   {
7542     try {
7543       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
7544     } catch (std::out_of_range& e) {
7545       {
7546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7547       };
7548     } catch (std::exception& e) {
7549       {
7550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7551       };
7552     } catch (Dali::DaliException e) {
7553       {
7554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7555       };
7556     } catch (...) {
7557       {
7558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7559       };
7560     }
7561   }
7562
7563   jresult = (void *)result;
7564   return jresult;
7565 }
7566
7567
7568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_2(void * jarg1, void * jarg2) {
7569   void * jresult ;
7570   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7571   Dali::Vector3 *arg2 = 0 ;
7572   Dali::Vector4 *result = 0 ;
7573
7574   arg1 = (Dali::Vector4 *)jarg1;
7575   arg2 = (Dali::Vector3 *)jarg2;
7576   if (!arg2) {
7577     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7578     return 0;
7579   }
7580   {
7581     try {
7582       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
7583     } catch (std::out_of_range& e) {
7584       {
7585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7586       };
7587     } catch (std::exception& e) {
7588       {
7589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7590       };
7591     } catch (Dali::DaliException e) {
7592       {
7593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7594       };
7595     } catch (...) {
7596       {
7597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7598       };
7599     }
7600   }
7601
7602   jresult = (void *)result;
7603   return jresult;
7604 }
7605
7606
7607 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Add(void * jarg1, void * jarg2) {
7608   void * jresult ;
7609   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7610   Dali::Vector4 *arg2 = 0 ;
7611   Dali::Vector4 result;
7612
7613   arg1 = (Dali::Vector4 *)jarg1;
7614   arg2 = (Dali::Vector4 *)jarg2;
7615   if (!arg2) {
7616     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7617     return 0;
7618   }
7619   {
7620     try {
7621       result = ((Dali::Vector4 const *)arg1)->operator +((Dali::Vector4 const &)*arg2);
7622     } catch (std::out_of_range& e) {
7623       {
7624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7625       };
7626     } catch (std::exception& e) {
7627       {
7628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7629       };
7630     } catch (Dali::DaliException e) {
7631       {
7632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7633       };
7634     } catch (...) {
7635       {
7636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7637       };
7638     }
7639   }
7640
7641   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7642   return jresult;
7643 }
7644
7645
7646 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AddAssign(void * jarg1, void * jarg2) {
7647   void * jresult ;
7648   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7649   Dali::Vector4 *arg2 = 0 ;
7650   Dali::Vector4 *result = 0 ;
7651
7652   arg1 = (Dali::Vector4 *)jarg1;
7653   arg2 = (Dali::Vector4 *)jarg2;
7654   if (!arg2) {
7655     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7656     return 0;
7657   }
7658   {
7659     try {
7660       result = (Dali::Vector4 *) &(arg1)->operator +=((Dali::Vector4 const &)*arg2);
7661     } catch (std::out_of_range& e) {
7662       {
7663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7664       };
7665     } catch (std::exception& e) {
7666       {
7667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7668       };
7669     } catch (Dali::DaliException e) {
7670       {
7671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7672       };
7673     } catch (...) {
7674       {
7675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7676       };
7677     }
7678   }
7679
7680   jresult = (void *)result;
7681   return jresult;
7682 }
7683
7684
7685 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_0(void * jarg1, void * jarg2) {
7686   void * jresult ;
7687   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7688   Dali::Vector4 *arg2 = 0 ;
7689   Dali::Vector4 result;
7690
7691   arg1 = (Dali::Vector4 *)jarg1;
7692   arg2 = (Dali::Vector4 *)jarg2;
7693   if (!arg2) {
7694     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7695     return 0;
7696   }
7697   {
7698     try {
7699       result = ((Dali::Vector4 const *)arg1)->operator -((Dali::Vector4 const &)*arg2);
7700     } catch (std::out_of_range& e) {
7701       {
7702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7703       };
7704     } catch (std::exception& e) {
7705       {
7706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7707       };
7708     } catch (Dali::DaliException e) {
7709       {
7710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7711       };
7712     } catch (...) {
7713       {
7714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7715       };
7716     }
7717   }
7718
7719   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7720   return jresult;
7721 }
7722
7723
7724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_SubtractAssign(void * jarg1, void * jarg2) {
7725   void * jresult ;
7726   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7727   Dali::Vector4 *arg2 = 0 ;
7728   Dali::Vector4 *result = 0 ;
7729
7730   arg1 = (Dali::Vector4 *)jarg1;
7731   arg2 = (Dali::Vector4 *)jarg2;
7732   if (!arg2) {
7733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7734     return 0;
7735   }
7736   {
7737     try {
7738       result = (Dali::Vector4 *) &(arg1)->operator -=((Dali::Vector4 const &)*arg2);
7739     } catch (std::out_of_range& e) {
7740       {
7741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7742       };
7743     } catch (std::exception& e) {
7744       {
7745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7746       };
7747     } catch (Dali::DaliException e) {
7748       {
7749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7750       };
7751     } catch (...) {
7752       {
7753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7754       };
7755     }
7756   }
7757
7758   jresult = (void *)result;
7759   return jresult;
7760 }
7761
7762
7763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_0(void * jarg1, void * jarg2) {
7764   void * jresult ;
7765   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7766   Dali::Vector4 *arg2 = 0 ;
7767   Dali::Vector4 result;
7768
7769   arg1 = (Dali::Vector4 *)jarg1;
7770   arg2 = (Dali::Vector4 *)jarg2;
7771   if (!arg2) {
7772     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7773     return 0;
7774   }
7775   {
7776     try {
7777       result = ((Dali::Vector4 const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
7778     } catch (std::out_of_range& e) {
7779       {
7780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7781       };
7782     } catch (std::exception& e) {
7783       {
7784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7785       };
7786     } catch (Dali::DaliException e) {
7787       {
7788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7789       };
7790     } catch (...) {
7791       {
7792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7793       };
7794     }
7795   }
7796
7797   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7798   return jresult;
7799 }
7800
7801
7802 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_1(void * jarg1, float jarg2) {
7803   void * jresult ;
7804   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7805   float arg2 ;
7806   Dali::Vector4 result;
7807
7808   arg1 = (Dali::Vector4 *)jarg1;
7809   arg2 = (float)jarg2;
7810   {
7811     try {
7812       result = ((Dali::Vector4 const *)arg1)->operator *(arg2);
7813     } catch (std::out_of_range& e) {
7814       {
7815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7816       };
7817     } catch (std::exception& e) {
7818       {
7819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7820       };
7821     } catch (Dali::DaliException e) {
7822       {
7823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7824       };
7825     } catch (...) {
7826       {
7827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7828       };
7829     }
7830   }
7831
7832   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7833   return jresult;
7834 }
7835
7836
7837 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
7838   void * jresult ;
7839   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7840   Dali::Vector4 *arg2 = 0 ;
7841   Dali::Vector4 *result = 0 ;
7842
7843   arg1 = (Dali::Vector4 *)jarg1;
7844   arg2 = (Dali::Vector4 *)jarg2;
7845   if (!arg2) {
7846     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7847     return 0;
7848   }
7849   {
7850     try {
7851       result = (Dali::Vector4 *) &(arg1)->operator *=((Dali::Vector4 const &)*arg2);
7852     } catch (std::out_of_range& e) {
7853       {
7854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7855       };
7856     } catch (std::exception& e) {
7857       {
7858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7859       };
7860     } catch (Dali::DaliException e) {
7861       {
7862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7863       };
7864     } catch (...) {
7865       {
7866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7867       };
7868     }
7869   }
7870
7871   jresult = (void *)result;
7872   return jresult;
7873 }
7874
7875
7876 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
7877   void * jresult ;
7878   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7879   float arg2 ;
7880   Dali::Vector4 *result = 0 ;
7881
7882   arg1 = (Dali::Vector4 *)jarg1;
7883   arg2 = (float)jarg2;
7884   {
7885     try {
7886       result = (Dali::Vector4 *) &(arg1)->operator *=(arg2);
7887     } catch (std::out_of_range& e) {
7888       {
7889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7890       };
7891     } catch (std::exception& e) {
7892       {
7893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7894       };
7895     } catch (Dali::DaliException e) {
7896       {
7897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7898       };
7899     } catch (...) {
7900       {
7901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7902       };
7903     }
7904   }
7905
7906   jresult = (void *)result;
7907   return jresult;
7908 }
7909
7910
7911 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_0(void * jarg1, void * jarg2) {
7912   void * jresult ;
7913   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7914   Dali::Vector4 *arg2 = 0 ;
7915   Dali::Vector4 result;
7916
7917   arg1 = (Dali::Vector4 *)jarg1;
7918   arg2 = (Dali::Vector4 *)jarg2;
7919   if (!arg2) {
7920     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7921     return 0;
7922   }
7923   {
7924     try {
7925       result = ((Dali::Vector4 const *)arg1)->operator /((Dali::Vector4 const &)*arg2);
7926     } catch (std::out_of_range& e) {
7927       {
7928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7929       };
7930     } catch (std::exception& e) {
7931       {
7932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7933       };
7934     } catch (Dali::DaliException e) {
7935       {
7936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7937       };
7938     } catch (...) {
7939       {
7940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7941       };
7942     }
7943   }
7944
7945   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7946   return jresult;
7947 }
7948
7949
7950 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_1(void * jarg1, float jarg2) {
7951   void * jresult ;
7952   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7953   float arg2 ;
7954   Dali::Vector4 result;
7955
7956   arg1 = (Dali::Vector4 *)jarg1;
7957   arg2 = (float)jarg2;
7958   {
7959     try {
7960       result = ((Dali::Vector4 const *)arg1)->operator /(arg2);
7961     } catch (std::out_of_range& e) {
7962       {
7963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7964       };
7965     } catch (std::exception& e) {
7966       {
7967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7968       };
7969     } catch (Dali::DaliException e) {
7970       {
7971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7972       };
7973     } catch (...) {
7974       {
7975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7976       };
7977     }
7978   }
7979
7980   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7981   return jresult;
7982 }
7983
7984
7985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
7986   void * jresult ;
7987   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7988   Dali::Vector4 *arg2 = 0 ;
7989   Dali::Vector4 *result = 0 ;
7990
7991   arg1 = (Dali::Vector4 *)jarg1;
7992   arg2 = (Dali::Vector4 *)jarg2;
7993   if (!arg2) {
7994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7995     return 0;
7996   }
7997   {
7998     try {
7999       result = (Dali::Vector4 *) &(arg1)->operator /=((Dali::Vector4 const &)*arg2);
8000     } catch (std::out_of_range& e) {
8001       {
8002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8003       };
8004     } catch (std::exception& e) {
8005       {
8006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8007       };
8008     } catch (Dali::DaliException e) {
8009       {
8010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8011       };
8012     } catch (...) {
8013       {
8014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8015       };
8016     }
8017   }
8018
8019   jresult = (void *)result;
8020   return jresult;
8021 }
8022
8023
8024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
8025   void * jresult ;
8026   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8027   float arg2 ;
8028   Dali::Vector4 *result = 0 ;
8029
8030   arg1 = (Dali::Vector4 *)jarg1;
8031   arg2 = (float)jarg2;
8032   {
8033     try {
8034       result = (Dali::Vector4 *) &(arg1)->operator /=(arg2);
8035     } catch (std::out_of_range& e) {
8036       {
8037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8038       };
8039     } catch (std::exception& e) {
8040       {
8041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8042       };
8043     } catch (Dali::DaliException e) {
8044       {
8045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8046       };
8047     } catch (...) {
8048       {
8049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8050       };
8051     }
8052   }
8053
8054   jresult = (void *)result;
8055   return jresult;
8056 }
8057
8058
8059 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_1(void * jarg1) {
8060   void * jresult ;
8061   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8062   Dali::Vector4 result;
8063
8064   arg1 = (Dali::Vector4 *)jarg1;
8065   {
8066     try {
8067       result = ((Dali::Vector4 const *)arg1)->operator -();
8068     } catch (std::out_of_range& e) {
8069       {
8070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8071       };
8072     } catch (std::exception& e) {
8073       {
8074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8075       };
8076     } catch (Dali::DaliException e) {
8077       {
8078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8079       };
8080     } catch (...) {
8081       {
8082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8083       };
8084     }
8085   }
8086
8087   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8088   return jresult;
8089 }
8090
8091
8092 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_EqualTo(void * jarg1, void * jarg2) {
8093   unsigned int jresult ;
8094   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8095   Dali::Vector4 *arg2 = 0 ;
8096   bool result;
8097
8098   arg1 = (Dali::Vector4 *)jarg1;
8099   arg2 = (Dali::Vector4 *)jarg2;
8100   if (!arg2) {
8101     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8102     return 0;
8103   }
8104   {
8105     try {
8106       result = (bool)((Dali::Vector4 const *)arg1)->operator ==((Dali::Vector4 const &)*arg2);
8107     } catch (std::out_of_range& e) {
8108       {
8109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8110       };
8111     } catch (std::exception& e) {
8112       {
8113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8114       };
8115     } catch (Dali::DaliException e) {
8116       {
8117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8118       };
8119     } catch (...) {
8120       {
8121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8122       };
8123     }
8124   }
8125
8126   jresult = result;
8127   return jresult;
8128 }
8129
8130
8131 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_NotEqualTo(void * jarg1, void * jarg2) {
8132   unsigned int jresult ;
8133   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8134   Dali::Vector4 *arg2 = 0 ;
8135   bool result;
8136
8137   arg1 = (Dali::Vector4 *)jarg1;
8138   arg2 = (Dali::Vector4 *)jarg2;
8139   if (!arg2) {
8140     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8141     return 0;
8142   }
8143   {
8144     try {
8145       result = (bool)((Dali::Vector4 const *)arg1)->operator !=((Dali::Vector4 const &)*arg2);
8146     } catch (std::out_of_range& e) {
8147       {
8148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8149       };
8150     } catch (std::exception& e) {
8151       {
8152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8153       };
8154     } catch (Dali::DaliException e) {
8155       {
8156         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8157       };
8158     } catch (...) {
8159       {
8160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8161       };
8162     }
8163   }
8164
8165   jresult = result;
8166   return jresult;
8167 }
8168
8169
8170 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
8171   float jresult ;
8172   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8173   unsigned int arg2 ;
8174   float *result = 0 ;
8175
8176   arg1 = (Dali::Vector4 *)jarg1;
8177   arg2 = (unsigned int)jarg2;
8178   {
8179     try {
8180       result = (float *) &((Dali::Vector4 const *)arg1)->operator [](arg2);
8181     } catch (std::out_of_range& e) {
8182       {
8183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8184       };
8185     } catch (std::exception& e) {
8186       {
8187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8188       };
8189     } catch (Dali::DaliException e) {
8190       {
8191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8192       };
8193     } catch (...) {
8194       {
8195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8196       };
8197     }
8198   }
8199
8200   jresult = *result;
8201   return jresult;
8202 }
8203
8204
8205 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_0(void * jarg1, void * jarg2) {
8206   float jresult ;
8207   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8208   Dali::Vector3 *arg2 = 0 ;
8209   float result;
8210
8211   arg1 = (Dali::Vector4 *)jarg1;
8212   arg2 = (Dali::Vector3 *)jarg2;
8213   if (!arg2) {
8214     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8215     return 0;
8216   }
8217   {
8218     try {
8219       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
8220     } catch (std::out_of_range& e) {
8221       {
8222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8223       };
8224     } catch (std::exception& e) {
8225       {
8226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8227       };
8228     } catch (Dali::DaliException e) {
8229       {
8230         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8231       };
8232     } catch (...) {
8233       {
8234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8235       };
8236     }
8237   }
8238
8239   jresult = result;
8240   return jresult;
8241 }
8242
8243
8244 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_1(void * jarg1, void * jarg2) {
8245   float jresult ;
8246   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8247   Dali::Vector4 *arg2 = 0 ;
8248   float result;
8249
8250   arg1 = (Dali::Vector4 *)jarg1;
8251   arg2 = (Dali::Vector4 *)jarg2;
8252   if (!arg2) {
8253     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8254     return 0;
8255   }
8256   {
8257     try {
8258       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector4 const &)*arg2);
8259     } catch (std::out_of_range& e) {
8260       {
8261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8262       };
8263     } catch (std::exception& e) {
8264       {
8265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8266       };
8267     } catch (Dali::DaliException e) {
8268       {
8269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8270       };
8271     } catch (...) {
8272       {
8273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8274       };
8275     }
8276   }
8277
8278   jresult = result;
8279   return jresult;
8280 }
8281
8282
8283 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot4(void * jarg1, void * jarg2) {
8284   float jresult ;
8285   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8286   Dali::Vector4 *arg2 = 0 ;
8287   float result;
8288
8289   arg1 = (Dali::Vector4 *)jarg1;
8290   arg2 = (Dali::Vector4 *)jarg2;
8291   if (!arg2) {
8292     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8293     return 0;
8294   }
8295   {
8296     try {
8297       result = (float)((Dali::Vector4 const *)arg1)->Dot4((Dali::Vector4 const &)*arg2);
8298     } catch (std::out_of_range& e) {
8299       {
8300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8301       };
8302     } catch (std::exception& e) {
8303       {
8304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8305       };
8306     } catch (Dali::DaliException e) {
8307       {
8308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8309       };
8310     } catch (...) {
8311       {
8312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8313       };
8314     }
8315   }
8316
8317   jresult = result;
8318   return jresult;
8319 }
8320
8321
8322 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Cross(void * jarg1, void * jarg2) {
8323   void * jresult ;
8324   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8325   Dali::Vector4 *arg2 = 0 ;
8326   Dali::Vector4 result;
8327
8328   arg1 = (Dali::Vector4 *)jarg1;
8329   arg2 = (Dali::Vector4 *)jarg2;
8330   if (!arg2) {
8331     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8332     return 0;
8333   }
8334   {
8335     try {
8336       result = ((Dali::Vector4 const *)arg1)->Cross((Dali::Vector4 const &)*arg2);
8337     } catch (std::out_of_range& e) {
8338       {
8339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8340       };
8341     } catch (std::exception& e) {
8342       {
8343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8344       };
8345     } catch (Dali::DaliException e) {
8346       {
8347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8348       };
8349     } catch (...) {
8350       {
8351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8352       };
8353     }
8354   }
8355
8356   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8357   return jresult;
8358 }
8359
8360
8361 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Length(void * jarg1) {
8362   float jresult ;
8363   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8364   float result;
8365
8366   arg1 = (Dali::Vector4 *)jarg1;
8367   {
8368     try {
8369       result = (float)((Dali::Vector4 const *)arg1)->Length();
8370     } catch (std::out_of_range& e) {
8371       {
8372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8373       };
8374     } catch (std::exception& e) {
8375       {
8376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8377       };
8378     } catch (Dali::DaliException e) {
8379       {
8380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8381       };
8382     } catch (...) {
8383       {
8384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8385       };
8386     }
8387   }
8388
8389   jresult = result;
8390   return jresult;
8391 }
8392
8393
8394 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_LengthSquared(void * jarg1) {
8395   float jresult ;
8396   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8397   float result;
8398
8399   arg1 = (Dali::Vector4 *)jarg1;
8400   {
8401     try {
8402       result = (float)((Dali::Vector4 const *)arg1)->LengthSquared();
8403     } catch (std::out_of_range& e) {
8404       {
8405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8406       };
8407     } catch (std::exception& e) {
8408       {
8409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8410       };
8411     } catch (Dali::DaliException e) {
8412       {
8413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8414       };
8415     } catch (...) {
8416       {
8417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8418       };
8419     }
8420   }
8421
8422   jresult = result;
8423   return jresult;
8424 }
8425
8426
8427 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Normalize(void * jarg1) {
8428   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8429
8430   arg1 = (Dali::Vector4 *)jarg1;
8431   {
8432     try {
8433       (arg1)->Normalize();
8434     } catch (std::out_of_range& e) {
8435       {
8436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8437       };
8438     } catch (std::exception& e) {
8439       {
8440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8441       };
8442     } catch (Dali::DaliException e) {
8443       {
8444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8445       };
8446     } catch (...) {
8447       {
8448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8449       };
8450     }
8451   }
8452
8453 }
8454
8455
8456 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Clamp(void * jarg1, void * jarg2, void * jarg3) {
8457   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8458   Dali::Vector4 *arg2 = 0 ;
8459   Dali::Vector4 *arg3 = 0 ;
8460
8461   arg1 = (Dali::Vector4 *)jarg1;
8462   arg2 = (Dali::Vector4 *)jarg2;
8463   if (!arg2) {
8464     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8465     return ;
8466   }
8467   arg3 = (Dali::Vector4 *)jarg3;
8468   if (!arg3) {
8469     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8470     return ;
8471   }
8472   {
8473     try {
8474       (arg1)->Clamp((Dali::Vector4 const &)*arg2,(Dali::Vector4 const &)*arg3);
8475     } catch (std::out_of_range& e) {
8476       {
8477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8478       };
8479     } catch (std::exception& e) {
8480       {
8481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8482       };
8483     } catch (Dali::DaliException e) {
8484       {
8485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8486       };
8487     } catch (...) {
8488       {
8489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8490       };
8491     }
8492   }
8493
8494 }
8495
8496
8497 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AsFloat__SWIG_0(void * jarg1) {
8498   void * jresult ;
8499   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8500   float *result = 0 ;
8501
8502   arg1 = (Dali::Vector4 *)jarg1;
8503   {
8504     try {
8505       result = (float *)((Dali::Vector4 const *)arg1)->AsFloat();
8506     } catch (std::out_of_range& e) {
8507       {
8508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8509       };
8510     } catch (std::exception& e) {
8511       {
8512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8513       };
8514     } catch (Dali::DaliException e) {
8515       {
8516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8517       };
8518     } catch (...) {
8519       {
8520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8521       };
8522     }
8523   }
8524
8525   jresult = (void *)result;
8526   return jresult;
8527 }
8528
8529
8530 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_X_set(void * jarg1, float jarg2) {
8531   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8532   float arg2 ;
8533
8534   arg1 = (Dali::Vector4 *)jarg1;
8535   arg2 = (float)jarg2;
8536   if (arg1) (arg1)->x = arg2;
8537 }
8538
8539
8540 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_X_get(void * jarg1) {
8541   float jresult ;
8542   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8543   float result;
8544
8545   arg1 = (Dali::Vector4 *)jarg1;
8546   result = (float) ((arg1)->x);
8547   jresult = result;
8548   return jresult;
8549 }
8550
8551
8552 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_r_set(void * jarg1, float jarg2) {
8553   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8554   float arg2 ;
8555
8556   arg1 = (Dali::Vector4 *)jarg1;
8557   arg2 = (float)jarg2;
8558   if (arg1) (arg1)->r = arg2;
8559 }
8560
8561
8562 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_r_get(void * jarg1) {
8563   float jresult ;
8564   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8565   float result;
8566
8567   arg1 = (Dali::Vector4 *)jarg1;
8568   result = (float) ((arg1)->r);
8569   jresult = result;
8570   return jresult;
8571 }
8572
8573
8574 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_s_set(void * jarg1, float jarg2) {
8575   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8576   float arg2 ;
8577
8578   arg1 = (Dali::Vector4 *)jarg1;
8579   arg2 = (float)jarg2;
8580   if (arg1) (arg1)->s = arg2;
8581 }
8582
8583
8584 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_s_get(void * jarg1) {
8585   float jresult ;
8586   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8587   float result;
8588
8589   arg1 = (Dali::Vector4 *)jarg1;
8590   result = (float) ((arg1)->s);
8591   jresult = result;
8592   return jresult;
8593 }
8594
8595
8596 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Y_set(void * jarg1, float jarg2) {
8597   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8598   float arg2 ;
8599
8600   arg1 = (Dali::Vector4 *)jarg1;
8601   arg2 = (float)jarg2;
8602   if (arg1) (arg1)->y = arg2;
8603 }
8604
8605
8606 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Y_get(void * jarg1) {
8607   float jresult ;
8608   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8609   float result;
8610
8611   arg1 = (Dali::Vector4 *)jarg1;
8612   result = (float) ((arg1)->y);
8613   jresult = result;
8614   return jresult;
8615 }
8616
8617
8618 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_g_set(void * jarg1, float jarg2) {
8619   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8620   float arg2 ;
8621
8622   arg1 = (Dali::Vector4 *)jarg1;
8623   arg2 = (float)jarg2;
8624   if (arg1) (arg1)->g = arg2;
8625 }
8626
8627
8628 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_g_get(void * jarg1) {
8629   float jresult ;
8630   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8631   float result;
8632
8633   arg1 = (Dali::Vector4 *)jarg1;
8634   result = (float) ((arg1)->g);
8635   jresult = result;
8636   return jresult;
8637 }
8638
8639
8640 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_t_set(void * jarg1, float jarg2) {
8641   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8642   float arg2 ;
8643
8644   arg1 = (Dali::Vector4 *)jarg1;
8645   arg2 = (float)jarg2;
8646   if (arg1) (arg1)->t = arg2;
8647 }
8648
8649
8650 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_t_get(void * jarg1) {
8651   float jresult ;
8652   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8653   float result;
8654
8655   arg1 = (Dali::Vector4 *)jarg1;
8656   result = (float) ((arg1)->t);
8657   jresult = result;
8658   return jresult;
8659 }
8660
8661
8662 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Z_set(void * jarg1, float jarg2) {
8663   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8664   float arg2 ;
8665
8666   arg1 = (Dali::Vector4 *)jarg1;
8667   arg2 = (float)jarg2;
8668   if (arg1) (arg1)->z = arg2;
8669 }
8670
8671
8672 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Z_get(void * jarg1) {
8673   float jresult ;
8674   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8675   float result;
8676
8677   arg1 = (Dali::Vector4 *)jarg1;
8678   result = (float) ((arg1)->z);
8679   jresult = result;
8680   return jresult;
8681 }
8682
8683
8684 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_b_set(void * jarg1, float jarg2) {
8685   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8686   float arg2 ;
8687
8688   arg1 = (Dali::Vector4 *)jarg1;
8689   arg2 = (float)jarg2;
8690   if (arg1) (arg1)->b = arg2;
8691 }
8692
8693
8694 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_b_get(void * jarg1) {
8695   float jresult ;
8696   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8697   float result;
8698
8699   arg1 = (Dali::Vector4 *)jarg1;
8700   result = (float) ((arg1)->b);
8701   jresult = result;
8702   return jresult;
8703 }
8704
8705
8706 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_p_set(void * jarg1, float jarg2) {
8707   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8708   float arg2 ;
8709
8710   arg1 = (Dali::Vector4 *)jarg1;
8711   arg2 = (float)jarg2;
8712   if (arg1) (arg1)->p = arg2;
8713 }
8714
8715
8716 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_p_get(void * jarg1) {
8717   float jresult ;
8718   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8719   float result;
8720
8721   arg1 = (Dali::Vector4 *)jarg1;
8722   result = (float) ((arg1)->p);
8723   jresult = result;
8724   return jresult;
8725 }
8726
8727
8728 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_W_set(void * jarg1, float jarg2) {
8729   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8730   float arg2 ;
8731
8732   arg1 = (Dali::Vector4 *)jarg1;
8733   arg2 = (float)jarg2;
8734   if (arg1) (arg1)->w = arg2;
8735 }
8736
8737
8738 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_W_get(void * jarg1) {
8739   float jresult ;
8740   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8741   float result;
8742
8743   arg1 = (Dali::Vector4 *)jarg1;
8744   result = (float) ((arg1)->w);
8745   jresult = result;
8746   return jresult;
8747 }
8748
8749
8750 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_a_set(void * jarg1, float jarg2) {
8751   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8752   float arg2 ;
8753
8754   arg1 = (Dali::Vector4 *)jarg1;
8755   arg2 = (float)jarg2;
8756   if (arg1) (arg1)->a = arg2;
8757 }
8758
8759
8760 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_a_get(void * jarg1) {
8761   float jresult ;
8762   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8763   float result;
8764
8765   arg1 = (Dali::Vector4 *)jarg1;
8766   result = (float) ((arg1)->a);
8767   jresult = result;
8768   return jresult;
8769 }
8770
8771
8772 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_q_set(void * jarg1, float jarg2) {
8773   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8774   float arg2 ;
8775
8776   arg1 = (Dali::Vector4 *)jarg1;
8777   arg2 = (float)jarg2;
8778   if (arg1) (arg1)->q = arg2;
8779 }
8780
8781
8782 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_q_get(void * jarg1) {
8783   float jresult ;
8784   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8785   float result;
8786
8787   arg1 = (Dali::Vector4 *)jarg1;
8788   result = (float) ((arg1)->q);
8789   jresult = result;
8790   return jresult;
8791 }
8792
8793
8794 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector4(void * jarg1) {
8795   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8796
8797   arg1 = (Dali::Vector4 *)jarg1;
8798   {
8799     try {
8800       delete arg1;
8801     } catch (std::out_of_range& e) {
8802       {
8803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8804       };
8805     } catch (std::exception& e) {
8806       {
8807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8808       };
8809     } catch (Dali::DaliException e) {
8810       {
8811         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8812       };
8813     } catch (...) {
8814       {
8815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8816       };
8817     }
8818   }
8819
8820 }
8821
8822
8823 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_2(void * jarg1, void * jarg2) {
8824   void * jresult ;
8825   Dali::Vector4 *arg1 = 0 ;
8826   Dali::Vector4 *arg2 = 0 ;
8827   Dali::Vector4 result;
8828
8829   arg1 = (Dali::Vector4 *)jarg1;
8830   if (!arg1) {
8831     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8832     return 0;
8833   }
8834   arg2 = (Dali::Vector4 *)jarg2;
8835   if (!arg2) {
8836     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8837     return 0;
8838   }
8839   {
8840     try {
8841       result = Dali::Min((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
8842     } catch (std::out_of_range& e) {
8843       {
8844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8845       };
8846     } catch (std::exception& e) {
8847       {
8848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8849       };
8850     } catch (Dali::DaliException e) {
8851       {
8852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8853       };
8854     } catch (...) {
8855       {
8856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8857       };
8858     }
8859   }
8860
8861   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8862   return jresult;
8863 }
8864
8865
8866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_2(void * jarg1, void * jarg2) {
8867   void * jresult ;
8868   Dali::Vector4 *arg1 = 0 ;
8869   Dali::Vector4 *arg2 = 0 ;
8870   Dali::Vector4 result;
8871
8872   arg1 = (Dali::Vector4 *)jarg1;
8873   if (!arg1) {
8874     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8875     return 0;
8876   }
8877   arg2 = (Dali::Vector4 *)jarg2;
8878   if (!arg2) {
8879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8880     return 0;
8881   }
8882   {
8883     try {
8884       result = Dali::Max((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
8885     } catch (std::out_of_range& e) {
8886       {
8887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8888       };
8889     } catch (std::exception& e) {
8890       {
8891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8892       };
8893     } catch (Dali::DaliException e) {
8894       {
8895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8896       };
8897     } catch (...) {
8898       {
8899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8900       };
8901     }
8902   }
8903
8904   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8905   return jresult;
8906 }
8907
8908
8909 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
8910   void * jresult ;
8911   Dali::Vector4 *arg1 = 0 ;
8912   float *arg2 = 0 ;
8913   float *arg3 = 0 ;
8914   float temp2 ;
8915   float temp3 ;
8916   Dali::Vector4 result;
8917
8918   arg1 = (Dali::Vector4 *)jarg1;
8919   if (!arg1) {
8920     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8921     return 0;
8922   }
8923   temp2 = (float)jarg2;
8924   arg2 = &temp2;
8925   temp3 = (float)jarg3;
8926   arg3 = &temp3;
8927   {
8928     try {
8929       result = Dali::Clamp((Dali::Vector4 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
8930     } catch (std::out_of_range& e) {
8931       {
8932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8933       };
8934     } catch (std::exception& e) {
8935       {
8936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8937       };
8938     } catch (Dali::DaliException e) {
8939       {
8940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8941       };
8942     } catch (...) {
8943       {
8944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8945       };
8946     }
8947   }
8948
8949   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8950   return jresult;
8951 }
8952
8953
8954 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_0() {
8955   void * jresult ;
8956   Dali::Uint16Pair *result = 0 ;
8957
8958   {
8959     try {
8960       result = (Dali::Uint16Pair *)new Dali::Uint16Pair();
8961     } catch (std::out_of_range& e) {
8962       {
8963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8964       };
8965     } catch (std::exception& e) {
8966       {
8967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8968       };
8969     } catch (Dali::DaliException e) {
8970       {
8971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8972       };
8973     } catch (...) {
8974       {
8975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8976       };
8977     }
8978   }
8979
8980   jresult = (void *)result;
8981   return jresult;
8982 }
8983
8984
8985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
8986   void * jresult ;
8987   uint32_t arg1 ;
8988   uint32_t arg2 ;
8989   Dali::Uint16Pair *result = 0 ;
8990
8991   arg1 = (uint32_t)jarg1;
8992   arg2 = (uint32_t)jarg2;
8993   {
8994     try {
8995       result = (Dali::Uint16Pair *)new Dali::Uint16Pair(arg1,arg2);
8996     } catch (std::out_of_range& e) {
8997       {
8998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8999       };
9000     } catch (std::exception& e) {
9001       {
9002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9003       };
9004     } catch (Dali::DaliException e) {
9005       {
9006         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9007       };
9008     } catch (...) {
9009       {
9010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9011       };
9012     }
9013   }
9014
9015   jresult = (void *)result;
9016   return jresult;
9017 }
9018
9019
9020 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_2(void * jarg1) {
9021   void * jresult ;
9022   Dali::Uint16Pair *arg1 = 0 ;
9023   Dali::Uint16Pair *result = 0 ;
9024
9025   arg1 = (Dali::Uint16Pair *)jarg1;
9026   if (!arg1) {
9027     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9028     return 0;
9029   }
9030   {
9031     try {
9032       result = (Dali::Uint16Pair *)new Dali::Uint16Pair((Dali::Uint16Pair const &)*arg1);
9033     } catch (std::out_of_range& e) {
9034       {
9035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9036       };
9037     } catch (std::exception& e) {
9038       {
9039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9040       };
9041     } catch (Dali::DaliException e) {
9042       {
9043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9044       };
9045     } catch (...) {
9046       {
9047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9048       };
9049     }
9050   }
9051
9052   jresult = (void *)result;
9053   return jresult;
9054 }
9055
9056
9057 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetWidth(void * jarg1, unsigned short jarg2) {
9058   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9059   uint16_t arg2 ;
9060
9061   arg1 = (Dali::Uint16Pair *)jarg1;
9062   arg2 = (uint16_t)jarg2;
9063   {
9064     try {
9065       (arg1)->SetWidth(arg2);
9066     } catch (std::out_of_range& e) {
9067       {
9068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9069       };
9070     } catch (std::exception& e) {
9071       {
9072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9073       };
9074     } catch (Dali::DaliException e) {
9075       {
9076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9077       };
9078     } catch (...) {
9079       {
9080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9081       };
9082     }
9083   }
9084
9085 }
9086
9087
9088 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetWidth(void * jarg1) {
9089   unsigned short jresult ;
9090   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9091   uint16_t result;
9092
9093   arg1 = (Dali::Uint16Pair *)jarg1;
9094   {
9095     try {
9096       result = ((Dali::Uint16Pair const *)arg1)->GetWidth();
9097     } catch (std::out_of_range& e) {
9098       {
9099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9100       };
9101     } catch (std::exception& e) {
9102       {
9103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9104       };
9105     } catch (Dali::DaliException e) {
9106       {
9107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9108       };
9109     } catch (...) {
9110       {
9111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9112       };
9113     }
9114   }
9115
9116   jresult = result;
9117   return jresult;
9118 }
9119
9120
9121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetHeight(void * jarg1, unsigned short jarg2) {
9122   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9123   uint16_t arg2 ;
9124
9125   arg1 = (Dali::Uint16Pair *)jarg1;
9126   arg2 = (uint16_t)jarg2;
9127   {
9128     try {
9129       (arg1)->SetHeight(arg2);
9130     } catch (std::out_of_range& e) {
9131       {
9132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9133       };
9134     } catch (std::exception& e) {
9135       {
9136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9137       };
9138     } catch (Dali::DaliException e) {
9139       {
9140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9141       };
9142     } catch (...) {
9143       {
9144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9145       };
9146     }
9147   }
9148
9149 }
9150
9151
9152 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetHeight(void * jarg1) {
9153   unsigned short jresult ;
9154   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9155   uint16_t result;
9156
9157   arg1 = (Dali::Uint16Pair *)jarg1;
9158   {
9159     try {
9160       result = ((Dali::Uint16Pair const *)arg1)->GetHeight();
9161     } catch (std::out_of_range& e) {
9162       {
9163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9164       };
9165     } catch (std::exception& e) {
9166       {
9167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9168       };
9169     } catch (Dali::DaliException e) {
9170       {
9171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9172       };
9173     } catch (...) {
9174       {
9175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9176       };
9177     }
9178   }
9179
9180   jresult = result;
9181   return jresult;
9182 }
9183
9184
9185 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetX(void * jarg1, unsigned short jarg2) {
9186   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9187   uint16_t arg2 ;
9188
9189   arg1 = (Dali::Uint16Pair *)jarg1;
9190   arg2 = (uint16_t)jarg2;
9191   {
9192     try {
9193       (arg1)->SetX(arg2);
9194     } catch (std::out_of_range& e) {
9195       {
9196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9197       };
9198     } catch (std::exception& e) {
9199       {
9200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9201       };
9202     } catch (Dali::DaliException e) {
9203       {
9204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9205       };
9206     } catch (...) {
9207       {
9208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9209       };
9210     }
9211   }
9212
9213 }
9214
9215
9216 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetX(void * jarg1) {
9217   unsigned short jresult ;
9218   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9219   uint16_t result;
9220
9221   arg1 = (Dali::Uint16Pair *)jarg1;
9222   {
9223     try {
9224       result = ((Dali::Uint16Pair const *)arg1)->GetX();
9225     } catch (std::out_of_range& e) {
9226       {
9227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9228       };
9229     } catch (std::exception& e) {
9230       {
9231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9232       };
9233     } catch (Dali::DaliException e) {
9234       {
9235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9236       };
9237     } catch (...) {
9238       {
9239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9240       };
9241     }
9242   }
9243
9244   jresult = result;
9245   return jresult;
9246 }
9247
9248
9249 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetY(void * jarg1, unsigned short jarg2) {
9250   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9251   uint16_t arg2 ;
9252
9253   arg1 = (Dali::Uint16Pair *)jarg1;
9254   arg2 = (uint16_t)jarg2;
9255   {
9256     try {
9257       (arg1)->SetY(arg2);
9258     } catch (std::out_of_range& e) {
9259       {
9260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9261       };
9262     } catch (std::exception& e) {
9263       {
9264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9265       };
9266     } catch (Dali::DaliException e) {
9267       {
9268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9269       };
9270     } catch (...) {
9271       {
9272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9273       };
9274     }
9275   }
9276
9277 }
9278
9279
9280 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetY(void * jarg1) {
9281   unsigned short jresult ;
9282   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9283   uint16_t result;
9284
9285   arg1 = (Dali::Uint16Pair *)jarg1;
9286   {
9287     try {
9288       result = ((Dali::Uint16Pair const *)arg1)->GetY();
9289     } catch (std::out_of_range& e) {
9290       {
9291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9292       };
9293     } catch (std::exception& e) {
9294       {
9295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9296       };
9297     } catch (Dali::DaliException e) {
9298       {
9299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9300       };
9301     } catch (...) {
9302       {
9303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9304       };
9305     }
9306   }
9307
9308   jresult = result;
9309   return jresult;
9310 }
9311
9312
9313 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Uint16Pair_Assign(void * jarg1, void * jarg2) {
9314   void * jresult ;
9315   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9316   Dali::Uint16Pair *arg2 = 0 ;
9317   Dali::Uint16Pair *result = 0 ;
9318
9319   arg1 = (Dali::Uint16Pair *)jarg1;
9320   arg2 = (Dali::Uint16Pair *)jarg2;
9321   if (!arg2) {
9322     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9323     return 0;
9324   }
9325   {
9326     try {
9327       result = (Dali::Uint16Pair *) &(arg1)->operator =((Dali::Uint16Pair const &)*arg2);
9328     } catch (std::out_of_range& e) {
9329       {
9330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9331       };
9332     } catch (std::exception& e) {
9333       {
9334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9335       };
9336     } catch (Dali::DaliException e) {
9337       {
9338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9339       };
9340     } catch (...) {
9341       {
9342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9343       };
9344     }
9345   }
9346
9347   jresult = (void *)result;
9348   return jresult;
9349 }
9350
9351
9352 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_EqualTo(void * jarg1, void * jarg2) {
9353   unsigned int jresult ;
9354   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9355   Dali::Uint16Pair *arg2 = 0 ;
9356   bool result;
9357
9358   arg1 = (Dali::Uint16Pair *)jarg1;
9359   arg2 = (Dali::Uint16Pair *)jarg2;
9360   if (!arg2) {
9361     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9362     return 0;
9363   }
9364   {
9365     try {
9366       result = (bool)((Dali::Uint16Pair const *)arg1)->operator ==((Dali::Uint16Pair const &)*arg2);
9367     } catch (std::out_of_range& e) {
9368       {
9369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9370       };
9371     } catch (std::exception& e) {
9372       {
9373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9374       };
9375     } catch (Dali::DaliException e) {
9376       {
9377         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9378       };
9379     } catch (...) {
9380       {
9381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9382       };
9383     }
9384   }
9385
9386   jresult = result;
9387   return jresult;
9388 }
9389
9390
9391 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_NotEqualTo(void * jarg1, void * jarg2) {
9392   unsigned int jresult ;
9393   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9394   Dali::Uint16Pair *arg2 = 0 ;
9395   bool result;
9396
9397   arg1 = (Dali::Uint16Pair *)jarg1;
9398   arg2 = (Dali::Uint16Pair *)jarg2;
9399   if (!arg2) {
9400     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9401     return 0;
9402   }
9403   {
9404     try {
9405       result = (bool)((Dali::Uint16Pair const *)arg1)->operator !=((Dali::Uint16Pair const &)*arg2);
9406     } catch (std::out_of_range& e) {
9407       {
9408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9409       };
9410     } catch (std::exception& e) {
9411       {
9412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9413       };
9414     } catch (Dali::DaliException e) {
9415       {
9416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9417       };
9418     } catch (...) {
9419       {
9420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9421       };
9422     }
9423   }
9424
9425   jresult = result;
9426   return jresult;
9427 }
9428
9429
9430 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_LessThan(void * jarg1, void * jarg2) {
9431   unsigned int jresult ;
9432   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9433   Dali::Uint16Pair *arg2 = 0 ;
9434   bool result;
9435
9436   arg1 = (Dali::Uint16Pair *)jarg1;
9437   arg2 = (Dali::Uint16Pair *)jarg2;
9438   if (!arg2) {
9439     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9440     return 0;
9441   }
9442   {
9443     try {
9444       result = (bool)((Dali::Uint16Pair const *)arg1)->operator <((Dali::Uint16Pair const &)*arg2);
9445     } catch (std::out_of_range& e) {
9446       {
9447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9448       };
9449     } catch (std::exception& e) {
9450       {
9451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9452       };
9453     } catch (Dali::DaliException e) {
9454       {
9455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9456       };
9457     } catch (...) {
9458       {
9459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9460       };
9461     }
9462   }
9463
9464   jresult = result;
9465   return jresult;
9466 }
9467
9468
9469 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_GreaterThan(void * jarg1, void * jarg2) {
9470   unsigned int jresult ;
9471   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9472   Dali::Uint16Pair *arg2 = 0 ;
9473   bool result;
9474
9475   arg1 = (Dali::Uint16Pair *)jarg1;
9476   arg2 = (Dali::Uint16Pair *)jarg2;
9477   if (!arg2) {
9478     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9479     return 0;
9480   }
9481   {
9482     try {
9483       result = (bool)((Dali::Uint16Pair const *)arg1)->operator >((Dali::Uint16Pair const &)*arg2);
9484     } catch (std::out_of_range& e) {
9485       {
9486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9487       };
9488     } catch (std::exception& e) {
9489       {
9490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9491       };
9492     } catch (Dali::DaliException e) {
9493       {
9494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9495       };
9496     } catch (...) {
9497       {
9498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9499       };
9500     }
9501   }
9502
9503   jresult = result;
9504   return jresult;
9505 }
9506
9507
9508 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Uint16Pair(void * jarg1) {
9509   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9510
9511   arg1 = (Dali::Uint16Pair *)jarg1;
9512   {
9513     try {
9514       delete arg1;
9515     } catch (std::out_of_range& e) {
9516       {
9517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9518       };
9519     } catch (std::exception& e) {
9520       {
9521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9522       };
9523     } catch (Dali::DaliException e) {
9524       {
9525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9526       };
9527     } catch (...) {
9528       {
9529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9530       };
9531     }
9532   }
9533
9534 }
9535
9536
9537 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_0() {
9538   void * jresult ;
9539   Dali::Degree *result = 0 ;
9540
9541   {
9542     try {
9543       result = (Dali::Degree *)new Dali::Degree();
9544     } catch (std::out_of_range& e) {
9545       {
9546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9547       };
9548     } catch (std::exception& e) {
9549       {
9550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9551       };
9552     } catch (Dali::DaliException e) {
9553       {
9554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9555       };
9556     } catch (...) {
9557       {
9558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9559       };
9560     }
9561   }
9562
9563   jresult = (void *)result;
9564   return jresult;
9565 }
9566
9567
9568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_1(float jarg1) {
9569   void * jresult ;
9570   float arg1 ;
9571   Dali::Degree *result = 0 ;
9572
9573   arg1 = (float)jarg1;
9574   {
9575     try {
9576       result = (Dali::Degree *)new Dali::Degree(arg1);
9577     } catch (std::out_of_range& e) {
9578       {
9579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9580       };
9581     } catch (std::exception& e) {
9582       {
9583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9584       };
9585     } catch (Dali::DaliException e) {
9586       {
9587         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9588       };
9589     } catch (...) {
9590       {
9591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9592       };
9593     }
9594   }
9595
9596   jresult = (void *)result;
9597   return jresult;
9598 }
9599
9600
9601 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_2(void * jarg1) {
9602   void * jresult ;
9603   Dali::Radian arg1 ;
9604   Dali::Radian *argp1 ;
9605   Dali::Degree *result = 0 ;
9606
9607   argp1 = (Dali::Radian *)jarg1;
9608   if (!argp1) {
9609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9610     return 0;
9611   }
9612   arg1 = *argp1;
9613   {
9614     try {
9615       result = (Dali::Degree *)new Dali::Degree(arg1);
9616     } catch (std::out_of_range& e) {
9617       {
9618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9619       };
9620     } catch (std::exception& e) {
9621       {
9622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9623       };
9624     } catch (Dali::DaliException e) {
9625       {
9626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9627       };
9628     } catch (...) {
9629       {
9630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9631       };
9632     }
9633   }
9634
9635   jresult = (void *)result;
9636   return jresult;
9637 }
9638
9639
9640 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Degree_degree_set(void * jarg1, float jarg2) {
9641   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9642   float arg2 ;
9643
9644   arg1 = (Dali::Degree *)jarg1;
9645   arg2 = (float)jarg2;
9646   if (arg1) (arg1)->degree = arg2;
9647 }
9648
9649
9650 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Degree_degree_get(void * jarg1) {
9651   float jresult ;
9652   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9653   float result;
9654
9655   arg1 = (Dali::Degree *)jarg1;
9656   result = (float) ((arg1)->degree);
9657   jresult = result;
9658   return jresult;
9659 }
9660
9661
9662 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Degree(void * jarg1) {
9663   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9664
9665   arg1 = (Dali::Degree *)jarg1;
9666   {
9667     try {
9668       delete arg1;
9669     } catch (std::out_of_range& e) {
9670       {
9671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9672       };
9673     } catch (std::exception& e) {
9674       {
9675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9676       };
9677     } catch (Dali::DaliException e) {
9678       {
9679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9680       };
9681     } catch (...) {
9682       {
9683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9684       };
9685     }
9686   }
9687
9688 }
9689
9690
9691 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_360_get() {
9692   void * jresult ;
9693   Dali::Radian *result = 0 ;
9694
9695   result = (Dali::Radian *)&Dali::ANGLE_360;
9696   jresult = (void *)result;
9697   return jresult;
9698 }
9699
9700
9701 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_315_get() {
9702   void * jresult ;
9703   Dali::Radian *result = 0 ;
9704
9705   result = (Dali::Radian *)&Dali::ANGLE_315;
9706   jresult = (void *)result;
9707   return jresult;
9708 }
9709
9710
9711 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_270_get() {
9712   void * jresult ;
9713   Dali::Radian *result = 0 ;
9714
9715   result = (Dali::Radian *)&Dali::ANGLE_270;
9716   jresult = (void *)result;
9717   return jresult;
9718 }
9719
9720
9721 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_225_get() {
9722   void * jresult ;
9723   Dali::Radian *result = 0 ;
9724
9725   result = (Dali::Radian *)&Dali::ANGLE_225;
9726   jresult = (void *)result;
9727   return jresult;
9728 }
9729
9730
9731 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_180_get() {
9732   void * jresult ;
9733   Dali::Radian *result = 0 ;
9734
9735   result = (Dali::Radian *)&Dali::ANGLE_180;
9736   jresult = (void *)result;
9737   return jresult;
9738 }
9739
9740
9741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_135_get() {
9742   void * jresult ;
9743   Dali::Radian *result = 0 ;
9744
9745   result = (Dali::Radian *)&Dali::ANGLE_135;
9746   jresult = (void *)result;
9747   return jresult;
9748 }
9749
9750
9751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_120_get() {
9752   void * jresult ;
9753   Dali::Radian *result = 0 ;
9754
9755   result = (Dali::Radian *)&Dali::ANGLE_120;
9756   jresult = (void *)result;
9757   return jresult;
9758 }
9759
9760
9761 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_90_get() {
9762   void * jresult ;
9763   Dali::Radian *result = 0 ;
9764
9765   result = (Dali::Radian *)&Dali::ANGLE_90;
9766   jresult = (void *)result;
9767   return jresult;
9768 }
9769
9770
9771 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_60_get() {
9772   void * jresult ;
9773   Dali::Radian *result = 0 ;
9774
9775   result = (Dali::Radian *)&Dali::ANGLE_60;
9776   jresult = (void *)result;
9777   return jresult;
9778 }
9779
9780
9781 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_45_get() {
9782   void * jresult ;
9783   Dali::Radian *result = 0 ;
9784
9785   result = (Dali::Radian *)&Dali::ANGLE_45;
9786   jresult = (void *)result;
9787   return jresult;
9788 }
9789
9790
9791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_30_get() {
9792   void * jresult ;
9793   Dali::Radian *result = 0 ;
9794
9795   result = (Dali::Radian *)&Dali::ANGLE_30;
9796   jresult = (void *)result;
9797   return jresult;
9798 }
9799
9800
9801 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_0_get() {
9802   void * jresult ;
9803   Dali::Radian *result = 0 ;
9804
9805   result = (Dali::Radian *)&Dali::ANGLE_0;
9806   jresult = (void *)result;
9807   return jresult;
9808 }
9809
9810
9811 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_5(void * jarg1, void * jarg2) {
9812   unsigned int jresult ;
9813   Dali::Degree *arg1 = 0 ;
9814   Dali::Degree *arg2 = 0 ;
9815   bool result;
9816
9817   arg1 = (Dali::Degree *)jarg1;
9818   if (!arg1) {
9819     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9820     return 0;
9821   }
9822   arg2 = (Dali::Degree *)jarg2;
9823   if (!arg2) {
9824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9825     return 0;
9826   }
9827   {
9828     try {
9829       result = (bool)Dali::operator ==((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
9830     } catch (std::out_of_range& e) {
9831       {
9832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9833       };
9834     } catch (std::exception& e) {
9835       {
9836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9837       };
9838     } catch (Dali::DaliException e) {
9839       {
9840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9841       };
9842     } catch (...) {
9843       {
9844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9845       };
9846     }
9847   }
9848
9849   jresult = result;
9850   return jresult;
9851 }
9852
9853
9854 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_4(void * jarg1, void * jarg2) {
9855   unsigned int jresult ;
9856   Dali::Degree *arg1 = 0 ;
9857   Dali::Degree *arg2 = 0 ;
9858   bool result;
9859
9860   arg1 = (Dali::Degree *)jarg1;
9861   if (!arg1) {
9862     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9863     return 0;
9864   }
9865   arg2 = (Dali::Degree *)jarg2;
9866   if (!arg2) {
9867     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9868     return 0;
9869   }
9870   {
9871     try {
9872       result = (bool)Dali::operator !=((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
9873     } catch (std::out_of_range& e) {
9874       {
9875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9876       };
9877     } catch (std::exception& e) {
9878       {
9879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9880       };
9881     } catch (Dali::DaliException e) {
9882       {
9883         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9884       };
9885     } catch (...) {
9886       {
9887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9888       };
9889     }
9890   }
9891
9892   jresult = result;
9893   return jresult;
9894 }
9895
9896
9897 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3) {
9898   void * jresult ;
9899   Dali::Degree arg1 ;
9900   float arg2 ;
9901   float arg3 ;
9902   Dali::Degree *argp1 ;
9903   Dali::Degree result;
9904
9905   argp1 = (Dali::Degree *)jarg1;
9906   if (!argp1) {
9907     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9908     return 0;
9909   }
9910   arg1 = *argp1;
9911   arg2 = (float)jarg2;
9912   arg3 = (float)jarg3;
9913   {
9914     try {
9915       result = Dali::Clamp(arg1,arg2,arg3);
9916     } catch (std::out_of_range& e) {
9917       {
9918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9919       };
9920     } catch (std::exception& e) {
9921       {
9922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9923       };
9924     } catch (Dali::DaliException e) {
9925       {
9926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9927       };
9928     } catch (...) {
9929       {
9930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9931       };
9932     }
9933   }
9934
9935   jresult = new Dali::Degree((const Dali::Degree &)result);
9936   return jresult;
9937 }
9938
9939
9940 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_0() {
9941   void * jresult ;
9942   Dali::Radian *result = 0 ;
9943
9944   {
9945     try {
9946       result = (Dali::Radian *)new Dali::Radian();
9947     } catch (std::out_of_range& e) {
9948       {
9949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9950       };
9951     } catch (std::exception& e) {
9952       {
9953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9954       };
9955     } catch (Dali::DaliException e) {
9956       {
9957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9958       };
9959     } catch (...) {
9960       {
9961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9962       };
9963     }
9964   }
9965
9966   jresult = (void *)result;
9967   return jresult;
9968 }
9969
9970
9971 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_1(float jarg1) {
9972   void * jresult ;
9973   float arg1 ;
9974   Dali::Radian *result = 0 ;
9975
9976   arg1 = (float)jarg1;
9977   {
9978     try {
9979       result = (Dali::Radian *)new Dali::Radian(arg1);
9980     } catch (std::out_of_range& e) {
9981       {
9982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9983       };
9984     } catch (std::exception& e) {
9985       {
9986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9987       };
9988     } catch (Dali::DaliException e) {
9989       {
9990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9991       };
9992     } catch (...) {
9993       {
9994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9995       };
9996     }
9997   }
9998
9999   jresult = (void *)result;
10000   return jresult;
10001 }
10002
10003
10004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_2(void * jarg1) {
10005   void * jresult ;
10006   Dali::Degree arg1 ;
10007   Dali::Degree *argp1 ;
10008   Dali::Radian *result = 0 ;
10009
10010   argp1 = (Dali::Degree *)jarg1;
10011   if (!argp1) {
10012     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10013     return 0;
10014   }
10015   arg1 = *argp1;
10016   {
10017     try {
10018       result = (Dali::Radian *)new Dali::Radian(arg1);
10019     } catch (std::out_of_range& e) {
10020       {
10021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10022       };
10023     } catch (std::exception& e) {
10024       {
10025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10026       };
10027     } catch (Dali::DaliException e) {
10028       {
10029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10030       };
10031     } catch (...) {
10032       {
10033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10034       };
10035     }
10036   }
10037
10038   jresult = (void *)result;
10039   return jresult;
10040 }
10041
10042
10043 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_0(void * jarg1, float jarg2) {
10044   void * jresult ;
10045   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10046   float arg2 ;
10047   Dali::Radian *result = 0 ;
10048
10049   arg1 = (Dali::Radian *)jarg1;
10050   arg2 = (float)jarg2;
10051   {
10052     try {
10053       result = (Dali::Radian *) &(arg1)->operator =(arg2);
10054     } catch (std::out_of_range& e) {
10055       {
10056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10057       };
10058     } catch (std::exception& e) {
10059       {
10060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10061       };
10062     } catch (Dali::DaliException e) {
10063       {
10064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10065       };
10066     } catch (...) {
10067       {
10068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10069       };
10070     }
10071   }
10072
10073   jresult = (void *)result;
10074   return jresult;
10075 }
10076
10077
10078 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_1(void * jarg1, void * jarg2) {
10079   void * jresult ;
10080   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10081   Dali::Degree arg2 ;
10082   Dali::Degree *argp2 ;
10083   Dali::Radian *result = 0 ;
10084
10085   arg1 = (Dali::Radian *)jarg1;
10086   argp2 = (Dali::Degree *)jarg2;
10087   if (!argp2) {
10088     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10089     return 0;
10090   }
10091   arg2 = *argp2;
10092   {
10093     try {
10094       result = (Dali::Radian *) &(arg1)->operator =(arg2);
10095     } catch (std::out_of_range& e) {
10096       {
10097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10098       };
10099     } catch (std::exception& e) {
10100       {
10101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10102       };
10103     } catch (Dali::DaliException e) {
10104       {
10105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10106       };
10107     } catch (...) {
10108       {
10109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10110       };
10111     }
10112   }
10113
10114   jresult = (void *)result;
10115   return jresult;
10116 }
10117
10118
10119 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_ConvertToFloat(void * jarg1) {
10120   float jresult ;
10121   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10122   float result;
10123
10124   arg1 = (Dali::Radian *)jarg1;
10125   {
10126     try {
10127       result = (float)((Dali::Radian const *)arg1)->operator float();
10128     } catch (std::out_of_range& e) {
10129       {
10130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10131       };
10132     } catch (std::exception& e) {
10133       {
10134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10135       };
10136     } catch (Dali::DaliException e) {
10137       {
10138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10139       };
10140     } catch (...) {
10141       {
10142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10143       };
10144     }
10145   }
10146
10147   jresult = result;
10148   return jresult;
10149 }
10150
10151
10152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Radian_radian_set(void * jarg1, float jarg2) {
10153   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10154   float arg2 ;
10155
10156   arg1 = (Dali::Radian *)jarg1;
10157   arg2 = (float)jarg2;
10158   if (arg1) (arg1)->radian = arg2;
10159 }
10160
10161
10162 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_radian_get(void * jarg1) {
10163   float jresult ;
10164   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10165   float result;
10166
10167   arg1 = (Dali::Radian *)jarg1;
10168   result = (float) ((arg1)->radian);
10169   jresult = result;
10170   return jresult;
10171 }
10172
10173
10174 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Radian(void * jarg1) {
10175   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10176
10177   arg1 = (Dali::Radian *)jarg1;
10178   {
10179     try {
10180       delete arg1;
10181     } catch (std::out_of_range& e) {
10182       {
10183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10184       };
10185     } catch (std::exception& e) {
10186       {
10187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10188       };
10189     } catch (Dali::DaliException e) {
10190       {
10191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
10192       };
10193     } catch (...) {
10194       {
10195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10196       };
10197     }
10198   }
10199
10200 }
10201
10202
10203 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_6(void * jarg1, void * jarg2) {
10204   unsigned int jresult ;
10205   Dali::Radian arg1 ;
10206   Dali::Radian arg2 ;
10207   Dali::Radian *argp1 ;
10208   Dali::Radian *argp2 ;
10209   bool result;
10210
10211   argp1 = (Dali::Radian *)jarg1;
10212   if (!argp1) {
10213     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10214     return 0;
10215   }
10216   arg1 = *argp1;
10217   argp2 = (Dali::Radian *)jarg2;
10218   if (!argp2) {
10219     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10220     return 0;
10221   }
10222   arg2 = *argp2;
10223   {
10224     try {
10225       result = (bool)Dali::operator ==(arg1,arg2);
10226     } catch (std::out_of_range& e) {
10227       {
10228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10229       };
10230     } catch (std::exception& e) {
10231       {
10232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10233       };
10234     } catch (Dali::DaliException e) {
10235       {
10236         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10237       };
10238     } catch (...) {
10239       {
10240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10241       };
10242     }
10243   }
10244
10245   jresult = result;
10246   return jresult;
10247 }
10248
10249
10250 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_5(void * jarg1, void * jarg2) {
10251   unsigned int jresult ;
10252   Dali::Radian arg1 ;
10253   Dali::Radian arg2 ;
10254   Dali::Radian *argp1 ;
10255   Dali::Radian *argp2 ;
10256   bool result;
10257
10258   argp1 = (Dali::Radian *)jarg1;
10259   if (!argp1) {
10260     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10261     return 0;
10262   }
10263   arg1 = *argp1;
10264   argp2 = (Dali::Radian *)jarg2;
10265   if (!argp2) {
10266     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10267     return 0;
10268   }
10269   arg2 = *argp2;
10270   {
10271     try {
10272       result = (bool)Dali::operator !=(arg1,arg2);
10273     } catch (std::out_of_range& e) {
10274       {
10275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10276       };
10277     } catch (std::exception& e) {
10278       {
10279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10280       };
10281     } catch (Dali::DaliException e) {
10282       {
10283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10284       };
10285     } catch (...) {
10286       {
10287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10288       };
10289     }
10290   }
10291
10292   jresult = result;
10293   return jresult;
10294 }
10295
10296
10297 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_7(void * jarg1, void * jarg2) {
10298   unsigned int jresult ;
10299   Dali::Radian arg1 ;
10300   Dali::Degree arg2 ;
10301   Dali::Radian *argp1 ;
10302   Dali::Degree *argp2 ;
10303   bool result;
10304
10305   argp1 = (Dali::Radian *)jarg1;
10306   if (!argp1) {
10307     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10308     return 0;
10309   }
10310   arg1 = *argp1;
10311   argp2 = (Dali::Degree *)jarg2;
10312   if (!argp2) {
10313     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10314     return 0;
10315   }
10316   arg2 = *argp2;
10317   {
10318     try {
10319       result = (bool)Dali::operator ==(arg1,arg2);
10320     } catch (std::out_of_range& e) {
10321       {
10322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10323       };
10324     } catch (std::exception& e) {
10325       {
10326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10327       };
10328     } catch (Dali::DaliException e) {
10329       {
10330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10331       };
10332     } catch (...) {
10333       {
10334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10335       };
10336     }
10337   }
10338
10339   jresult = result;
10340   return jresult;
10341 }
10342
10343
10344 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_6(void * jarg1, void * jarg2) {
10345   unsigned int jresult ;
10346   Dali::Radian arg1 ;
10347   Dali::Degree arg2 ;
10348   Dali::Radian *argp1 ;
10349   Dali::Degree *argp2 ;
10350   bool result;
10351
10352   argp1 = (Dali::Radian *)jarg1;
10353   if (!argp1) {
10354     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10355     return 0;
10356   }
10357   arg1 = *argp1;
10358   argp2 = (Dali::Degree *)jarg2;
10359   if (!argp2) {
10360     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10361     return 0;
10362   }
10363   arg2 = *argp2;
10364   {
10365     try {
10366       result = (bool)Dali::operator !=(arg1,arg2);
10367     } catch (std::out_of_range& e) {
10368       {
10369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10370       };
10371     } catch (std::exception& e) {
10372       {
10373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10374       };
10375     } catch (Dali::DaliException e) {
10376       {
10377         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10378       };
10379     } catch (...) {
10380       {
10381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10382       };
10383     }
10384   }
10385
10386   jresult = result;
10387   return jresult;
10388 }
10389
10390
10391 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_8(void * jarg1, void * jarg2) {
10392   unsigned int jresult ;
10393   Dali::Degree arg1 ;
10394   Dali::Radian arg2 ;
10395   Dali::Degree *argp1 ;
10396   Dali::Radian *argp2 ;
10397   bool result;
10398
10399   argp1 = (Dali::Degree *)jarg1;
10400   if (!argp1) {
10401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10402     return 0;
10403   }
10404   arg1 = *argp1;
10405   argp2 = (Dali::Radian *)jarg2;
10406   if (!argp2) {
10407     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10408     return 0;
10409   }
10410   arg2 = *argp2;
10411   {
10412     try {
10413       result = (bool)Dali::operator ==(arg1,arg2);
10414     } catch (std::out_of_range& e) {
10415       {
10416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10417       };
10418     } catch (std::exception& e) {
10419       {
10420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10421       };
10422     } catch (Dali::DaliException e) {
10423       {
10424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10425       };
10426     } catch (...) {
10427       {
10428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10429       };
10430     }
10431   }
10432
10433   jresult = result;
10434   return jresult;
10435 }
10436
10437
10438 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_7(void * jarg1, void * jarg2) {
10439   unsigned int jresult ;
10440   Dali::Degree arg1 ;
10441   Dali::Radian arg2 ;
10442   Dali::Degree *argp1 ;
10443   Dali::Radian *argp2 ;
10444   bool result;
10445
10446   argp1 = (Dali::Degree *)jarg1;
10447   if (!argp1) {
10448     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10449     return 0;
10450   }
10451   arg1 = *argp1;
10452   argp2 = (Dali::Radian *)jarg2;
10453   if (!argp2) {
10454     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10455     return 0;
10456   }
10457   arg2 = *argp2;
10458   {
10459     try {
10460       result = (bool)Dali::operator !=(arg1,arg2);
10461     } catch (std::out_of_range& e) {
10462       {
10463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10464       };
10465     } catch (std::exception& e) {
10466       {
10467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10468       };
10469     } catch (Dali::DaliException e) {
10470       {
10471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10472       };
10473     } catch (...) {
10474       {
10475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10476       };
10477     }
10478   }
10479
10480   jresult = result;
10481   return jresult;
10482 }
10483
10484
10485 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_0(void * jarg1, void * jarg2) {
10486   unsigned int jresult ;
10487   Dali::Radian arg1 ;
10488   Dali::Radian arg2 ;
10489   Dali::Radian *argp1 ;
10490   Dali::Radian *argp2 ;
10491   bool result;
10492
10493   argp1 = (Dali::Radian *)jarg1;
10494   if (!argp1) {
10495     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10496     return 0;
10497   }
10498   arg1 = *argp1;
10499   argp2 = (Dali::Radian *)jarg2;
10500   if (!argp2) {
10501     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10502     return 0;
10503   }
10504   arg2 = *argp2;
10505   {
10506     try {
10507       result = (bool)Dali::operator >(arg1,arg2);
10508     } catch (std::out_of_range& e) {
10509       {
10510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10511       };
10512     } catch (std::exception& e) {
10513       {
10514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10515       };
10516     } catch (Dali::DaliException e) {
10517       {
10518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10519       };
10520     } catch (...) {
10521       {
10522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10523       };
10524     }
10525   }
10526
10527   jresult = result;
10528   return jresult;
10529 }
10530
10531
10532 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_1(void * jarg1, void * jarg2) {
10533   unsigned int jresult ;
10534   Dali::Radian arg1 ;
10535   Dali::Degree arg2 ;
10536   Dali::Radian *argp1 ;
10537   Dali::Degree *argp2 ;
10538   bool result;
10539
10540   argp1 = (Dali::Radian *)jarg1;
10541   if (!argp1) {
10542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10543     return 0;
10544   }
10545   arg1 = *argp1;
10546   argp2 = (Dali::Degree *)jarg2;
10547   if (!argp2) {
10548     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10549     return 0;
10550   }
10551   arg2 = *argp2;
10552   {
10553     try {
10554       result = (bool)Dali::operator >(arg1,arg2);
10555     } catch (std::out_of_range& e) {
10556       {
10557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10558       };
10559     } catch (std::exception& e) {
10560       {
10561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10562       };
10563     } catch (Dali::DaliException e) {
10564       {
10565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10566       };
10567     } catch (...) {
10568       {
10569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10570       };
10571     }
10572   }
10573
10574   jresult = result;
10575   return jresult;
10576 }
10577
10578
10579 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_2(void * jarg1, void * jarg2) {
10580   unsigned int jresult ;
10581   Dali::Degree arg1 ;
10582   Dali::Radian arg2 ;
10583   Dali::Degree *argp1 ;
10584   Dali::Radian *argp2 ;
10585   bool result;
10586
10587   argp1 = (Dali::Degree *)jarg1;
10588   if (!argp1) {
10589     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10590     return 0;
10591   }
10592   arg1 = *argp1;
10593   argp2 = (Dali::Radian *)jarg2;
10594   if (!argp2) {
10595     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10596     return 0;
10597   }
10598   arg2 = *argp2;
10599   {
10600     try {
10601       result = (bool)Dali::operator >(arg1,arg2);
10602     } catch (std::out_of_range& e) {
10603       {
10604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10605       };
10606     } catch (std::exception& e) {
10607       {
10608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10609       };
10610     } catch (Dali::DaliException e) {
10611       {
10612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10613       };
10614     } catch (...) {
10615       {
10616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10617       };
10618     }
10619   }
10620
10621   jresult = result;
10622   return jresult;
10623 }
10624
10625
10626 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_0(void * jarg1, void * jarg2) {
10627   unsigned int jresult ;
10628   Dali::Radian arg1 ;
10629   Dali::Radian arg2 ;
10630   Dali::Radian *argp1 ;
10631   Dali::Radian *argp2 ;
10632   bool result;
10633
10634   argp1 = (Dali::Radian *)jarg1;
10635   if (!argp1) {
10636     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10637     return 0;
10638   }
10639   arg1 = *argp1;
10640   argp2 = (Dali::Radian *)jarg2;
10641   if (!argp2) {
10642     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10643     return 0;
10644   }
10645   arg2 = *argp2;
10646   {
10647     try {
10648       result = (bool)Dali::operator <(arg1,arg2);
10649     } catch (std::out_of_range& e) {
10650       {
10651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10652       };
10653     } catch (std::exception& e) {
10654       {
10655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10656       };
10657     } catch (Dali::DaliException e) {
10658       {
10659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10660       };
10661     } catch (...) {
10662       {
10663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10664       };
10665     }
10666   }
10667
10668   jresult = result;
10669   return jresult;
10670 }
10671
10672
10673 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_1(void * jarg1, void * jarg2) {
10674   unsigned int jresult ;
10675   Dali::Radian arg1 ;
10676   Dali::Degree arg2 ;
10677   Dali::Radian *argp1 ;
10678   Dali::Degree *argp2 ;
10679   bool result;
10680
10681   argp1 = (Dali::Radian *)jarg1;
10682   if (!argp1) {
10683     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10684     return 0;
10685   }
10686   arg1 = *argp1;
10687   argp2 = (Dali::Degree *)jarg2;
10688   if (!argp2) {
10689     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10690     return 0;
10691   }
10692   arg2 = *argp2;
10693   {
10694     try {
10695       result = (bool)Dali::operator <(arg1,arg2);
10696     } catch (std::out_of_range& e) {
10697       {
10698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10699       };
10700     } catch (std::exception& e) {
10701       {
10702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10703       };
10704     } catch (Dali::DaliException e) {
10705       {
10706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10707       };
10708     } catch (...) {
10709       {
10710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10711       };
10712     }
10713   }
10714
10715   jresult = result;
10716   return jresult;
10717 }
10718
10719
10720 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_2(void * jarg1, void * jarg2) {
10721   unsigned int jresult ;
10722   Dali::Degree arg1 ;
10723   Dali::Radian arg2 ;
10724   Dali::Degree *argp1 ;
10725   Dali::Radian *argp2 ;
10726   bool result;
10727
10728   argp1 = (Dali::Degree *)jarg1;
10729   if (!argp1) {
10730     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10731     return 0;
10732   }
10733   arg1 = *argp1;
10734   argp2 = (Dali::Radian *)jarg2;
10735   if (!argp2) {
10736     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10737     return 0;
10738   }
10739   arg2 = *argp2;
10740   {
10741     try {
10742       result = (bool)Dali::operator <(arg1,arg2);
10743     } catch (std::out_of_range& e) {
10744       {
10745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10746       };
10747     } catch (std::exception& e) {
10748       {
10749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10750       };
10751     } catch (Dali::DaliException e) {
10752       {
10753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10754       };
10755     } catch (...) {
10756       {
10757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10758       };
10759     }
10760   }
10761
10762   jresult = result;
10763   return jresult;
10764 }
10765
10766
10767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Multiply(void * jarg1, float jarg2) {
10768   void * jresult ;
10769   Dali::Radian arg1 ;
10770   float arg2 ;
10771   Dali::Radian *argp1 ;
10772   Dali::Radian result;
10773
10774   argp1 = (Dali::Radian *)jarg1;
10775   if (!argp1) {
10776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10777     return 0;
10778   }
10779   arg1 = *argp1;
10780   arg2 = (float)jarg2;
10781   {
10782     try {
10783       result = Dali::operator *(arg1,arg2);
10784     } catch (std::out_of_range& e) {
10785       {
10786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10787       };
10788     } catch (std::exception& e) {
10789       {
10790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10791       };
10792     } catch (Dali::DaliException e) {
10793       {
10794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10795       };
10796     } catch (...) {
10797       {
10798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10799       };
10800     }
10801   }
10802
10803   jresult = new Dali::Radian((const Dali::Radian &)result);
10804   return jresult;
10805 }
10806
10807
10808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Subtract(void * jarg1) {
10809   void * jresult ;
10810   Dali::Radian arg1 ;
10811   Dali::Radian *argp1 ;
10812   Dali::Radian result;
10813
10814   argp1 = (Dali::Radian *)jarg1;
10815   if (!argp1) {
10816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10817     return 0;
10818   }
10819   arg1 = *argp1;
10820   {
10821     try {
10822       result = Dali::operator -(arg1);
10823     } catch (std::out_of_range& e) {
10824       {
10825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10826       };
10827     } catch (std::exception& e) {
10828       {
10829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10830       };
10831     } catch (Dali::DaliException e) {
10832       {
10833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10834       };
10835     } catch (...) {
10836       {
10837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10838       };
10839     }
10840   }
10841
10842   jresult = new Dali::Radian((const Dali::Radian &)result);
10843   return jresult;
10844 }
10845
10846
10847 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_4(void * jarg1, float jarg2, float jarg3) {
10848   void * jresult ;
10849   Dali::Radian arg1 ;
10850   float arg2 ;
10851   float arg3 ;
10852   Dali::Radian *argp1 ;
10853   Dali::Radian result;
10854
10855   argp1 = (Dali::Radian *)jarg1;
10856   if (!argp1) {
10857     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10858     return 0;
10859   }
10860   arg1 = *argp1;
10861   arg2 = (float)jarg2;
10862   arg3 = (float)jarg3;
10863   {
10864     try {
10865       result = Dali::Clamp(arg1,arg2,arg3);
10866     } catch (std::out_of_range& e) {
10867       {
10868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10869       };
10870     } catch (std::exception& e) {
10871       {
10872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10873       };
10874     } catch (Dali::DaliException e) {
10875       {
10876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10877       };
10878     } catch (...) {
10879       {
10880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10881       };
10882     }
10883   }
10884
10885   jresult = new Dali::Radian((const Dali::Radian &)result);
10886   return jresult;
10887 }
10888
10889
10890 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_0() {
10891   void * jresult ;
10892   Dali::Quaternion *result = 0 ;
10893
10894   {
10895     try {
10896       result = (Dali::Quaternion *)new Dali::Quaternion();
10897     } catch (std::out_of_range& e) {
10898       {
10899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10900       };
10901     } catch (std::exception& e) {
10902       {
10903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10904       };
10905     } catch (Dali::DaliException e) {
10906       {
10907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10908       };
10909     } catch (...) {
10910       {
10911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10912       };
10913     }
10914   }
10915
10916   jresult = (void *)result;
10917   return jresult;
10918 }
10919
10920
10921 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_1(void * jarg1, void * jarg2) {
10922   void * jresult ;
10923   Dali::Radian arg1 ;
10924   Dali::Vector3 *arg2 = 0 ;
10925   Dali::Radian *argp1 ;
10926   Dali::Quaternion *result = 0 ;
10927
10928   argp1 = (Dali::Radian *)jarg1;
10929   if (!argp1) {
10930     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10931     return 0;
10932   }
10933   arg1 = *argp1;
10934   arg2 = (Dali::Vector3 *)jarg2;
10935   if (!arg2) {
10936     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
10937     return 0;
10938   }
10939   {
10940     try {
10941       result = (Dali::Quaternion *)new Dali::Quaternion(arg1,(Dali::Vector3 const &)*arg2);
10942     } catch (std::out_of_range& e) {
10943       {
10944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10945       };
10946     } catch (std::exception& e) {
10947       {
10948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10949       };
10950     } catch (Dali::DaliException e) {
10951       {
10952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10953       };
10954     } catch (...) {
10955       {
10956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10957       };
10958     }
10959   }
10960
10961   jresult = (void *)result;
10962   return jresult;
10963 }
10964
10965
10966 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rotation(void * jarg1) {
10967   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10968
10969   arg1 = (Dali::Quaternion *)jarg1;
10970   {
10971     try {
10972       delete arg1;
10973     } catch (std::out_of_range& e) {
10974       {
10975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10976       };
10977     } catch (std::exception& e) {
10978       {
10979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10980       };
10981     } catch (Dali::DaliException e) {
10982       {
10983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
10984       };
10985     } catch (...) {
10986       {
10987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10988       };
10989     }
10990   }
10991
10992 }
10993
10994
10995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_IDENTITY_get() {
10996   void * jresult ;
10997   Dali::Quaternion *result = 0 ;
10998
10999   result = (Dali::Quaternion *)&Dali::Quaternion::IDENTITY;
11000   jresult = (void *)result;
11001   return jresult;
11002 }
11003
11004
11005 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_IsIdentity(void * jarg1) {
11006   unsigned int jresult ;
11007   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11008   bool result;
11009
11010   arg1 = (Dali::Quaternion *)jarg1;
11011   {
11012     try {
11013       result = (bool)((Dali::Quaternion const *)arg1)->IsIdentity();
11014     } catch (std::out_of_range& e) {
11015       {
11016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11017       };
11018     } catch (std::exception& e) {
11019       {
11020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11021       };
11022     } catch (Dali::DaliException e) {
11023       {
11024         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11025       };
11026     } catch (...) {
11027       {
11028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11029       };
11030     }
11031   }
11032
11033   jresult = result;
11034   return jresult;
11035 }
11036
11037
11038 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_GetAxisAngle(void * jarg1, void * jarg2, void * jarg3) {
11039   unsigned int jresult ;
11040   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11041   Dali::Vector3 *arg2 = 0 ;
11042   Dali::Radian *arg3 = 0 ;
11043   bool result;
11044
11045   arg1 = (Dali::Quaternion *)jarg1;
11046   arg2 = (Dali::Vector3 *)jarg2;
11047   if (!arg2) {
11048     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
11049     return 0;
11050   }
11051   arg3 = (Dali::Radian *)jarg3;
11052   if (!arg3) {
11053     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian & type is null", 0);
11054     return 0;
11055   }
11056   {
11057     try {
11058       result = (bool)((Dali::Quaternion const *)arg1)->ToAxisAngle(*arg2,*arg3);
11059     } catch (std::out_of_range& e) {
11060       {
11061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11062       };
11063     } catch (std::exception& e) {
11064       {
11065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11066       };
11067     } catch (Dali::DaliException e) {
11068       {
11069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11070       };
11071     } catch (...) {
11072       {
11073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11074       };
11075     }
11076   }
11077
11078   jresult = result;
11079   return jresult;
11080 }
11081
11082
11083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Add(void * jarg1, void * jarg2) {
11084   void * jresult ;
11085   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11086   Dali::Quaternion *arg2 = 0 ;
11087   Dali::Quaternion result;
11088
11089   arg1 = (Dali::Quaternion *)jarg1;
11090   arg2 = (Dali::Quaternion *)jarg2;
11091   if (!arg2) {
11092     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11093     return 0;
11094   }
11095   {
11096     try {
11097       result = ((Dali::Quaternion const *)arg1)->operator +((Dali::Quaternion const &)*arg2);
11098     } catch (std::out_of_range& e) {
11099       {
11100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11101       };
11102     } catch (std::exception& e) {
11103       {
11104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11105       };
11106     } catch (Dali::DaliException e) {
11107       {
11108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11109       };
11110     } catch (...) {
11111       {
11112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11113       };
11114     }
11115   }
11116
11117   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11118   return jresult;
11119 }
11120
11121
11122 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_0(void * jarg1, void * jarg2) {
11123   void * jresult ;
11124   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11125   Dali::Quaternion *arg2 = 0 ;
11126   Dali::Quaternion result;
11127
11128   arg1 = (Dali::Quaternion *)jarg1;
11129   arg2 = (Dali::Quaternion *)jarg2;
11130   if (!arg2) {
11131     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11132     return 0;
11133   }
11134   {
11135     try {
11136       result = ((Dali::Quaternion const *)arg1)->operator -((Dali::Quaternion const &)*arg2);
11137     } catch (std::out_of_range& e) {
11138       {
11139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11140       };
11141     } catch (std::exception& e) {
11142       {
11143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11144       };
11145     } catch (Dali::DaliException e) {
11146       {
11147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11148       };
11149     } catch (...) {
11150       {
11151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11152       };
11153     }
11154   }
11155
11156   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11157   return jresult;
11158 }
11159
11160
11161 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_0(void * jarg1, void * jarg2) {
11162   void * jresult ;
11163   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11164   Dali::Quaternion *arg2 = 0 ;
11165   Dali::Quaternion result;
11166
11167   arg1 = (Dali::Quaternion *)jarg1;
11168   arg2 = (Dali::Quaternion *)jarg2;
11169   if (!arg2) {
11170     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11171     return 0;
11172   }
11173   {
11174     try {
11175       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Quaternion const &)*arg2);
11176     } catch (std::out_of_range& e) {
11177       {
11178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11179       };
11180     } catch (std::exception& e) {
11181       {
11182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11183       };
11184     } catch (Dali::DaliException e) {
11185       {
11186         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11187       };
11188     } catch (...) {
11189       {
11190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11191       };
11192     }
11193   }
11194
11195   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11196   return jresult;
11197 }
11198
11199
11200 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_1(void * jarg1, void * jarg2) {
11201   void * jresult ;
11202   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11203   Dali::Vector3 *arg2 = 0 ;
11204   Dali::Vector3 result;
11205
11206   arg1 = (Dali::Quaternion *)jarg1;
11207   arg2 = (Dali::Vector3 *)jarg2;
11208   if (!arg2) {
11209     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11210     return 0;
11211   }
11212   {
11213     try {
11214       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
11215     } catch (std::out_of_range& e) {
11216       {
11217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11218       };
11219     } catch (std::exception& e) {
11220       {
11221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11222       };
11223     } catch (Dali::DaliException e) {
11224       {
11225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11226       };
11227     } catch (...) {
11228       {
11229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11230       };
11231     }
11232   }
11233
11234   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11235   return jresult;
11236 }
11237
11238
11239 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_0(void * jarg1, void * jarg2) {
11240   void * jresult ;
11241   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11242   Dali::Quaternion *arg2 = 0 ;
11243   Dali::Quaternion result;
11244
11245   arg1 = (Dali::Quaternion *)jarg1;
11246   arg2 = (Dali::Quaternion *)jarg2;
11247   if (!arg2) {
11248     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11249     return 0;
11250   }
11251   {
11252     try {
11253       result = ((Dali::Quaternion const *)arg1)->operator /((Dali::Quaternion const &)*arg2);
11254     } catch (std::out_of_range& e) {
11255       {
11256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11257       };
11258     } catch (std::exception& e) {
11259       {
11260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11261       };
11262     } catch (Dali::DaliException e) {
11263       {
11264         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11265       };
11266     } catch (...) {
11267       {
11268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11269       };
11270     }
11271   }
11272
11273   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11274   return jresult;
11275 }
11276
11277
11278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_2(void * jarg1, float jarg2) {
11279   void * jresult ;
11280   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11281   float arg2 ;
11282   Dali::Quaternion result;
11283
11284   arg1 = (Dali::Quaternion *)jarg1;
11285   arg2 = (float)jarg2;
11286   {
11287     try {
11288       result = ((Dali::Quaternion const *)arg1)->operator *(arg2);
11289     } catch (std::out_of_range& e) {
11290       {
11291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11292       };
11293     } catch (std::exception& e) {
11294       {
11295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11296       };
11297     } catch (Dali::DaliException e) {
11298       {
11299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11300       };
11301     } catch (...) {
11302       {
11303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11304       };
11305     }
11306   }
11307
11308   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11309   return jresult;
11310 }
11311
11312
11313 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_1(void * jarg1, float jarg2) {
11314   void * jresult ;
11315   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11316   float arg2 ;
11317   Dali::Quaternion result;
11318
11319   arg1 = (Dali::Quaternion *)jarg1;
11320   arg2 = (float)jarg2;
11321   {
11322     try {
11323       result = ((Dali::Quaternion const *)arg1)->operator /(arg2);
11324     } catch (std::out_of_range& e) {
11325       {
11326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11327       };
11328     } catch (std::exception& e) {
11329       {
11330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11331       };
11332     } catch (Dali::DaliException e) {
11333       {
11334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11335       };
11336     } catch (...) {
11337       {
11338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11339       };
11340     }
11341   }
11342
11343   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11344   return jresult;
11345 }
11346
11347
11348 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_1(void * jarg1) {
11349   void * jresult ;
11350   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11351   Dali::Quaternion result;
11352
11353   arg1 = (Dali::Quaternion *)jarg1;
11354   {
11355     try {
11356       result = ((Dali::Quaternion const *)arg1)->operator -();
11357     } catch (std::out_of_range& e) {
11358       {
11359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11360       };
11361     } catch (std::exception& e) {
11362       {
11363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11364       };
11365     } catch (Dali::DaliException e) {
11366       {
11367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11368       };
11369     } catch (...) {
11370       {
11371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11372       };
11373     }
11374   }
11375
11376   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11377   return jresult;
11378 }
11379
11380
11381 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_AddAssign(void * jarg1, void * jarg2) {
11382   void * jresult ;
11383   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11384   Dali::Quaternion *arg2 = 0 ;
11385   Dali::Quaternion *result = 0 ;
11386
11387   arg1 = (Dali::Quaternion *)jarg1;
11388   arg2 = (Dali::Quaternion *)jarg2;
11389   if (!arg2) {
11390     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11391     return 0;
11392   }
11393   {
11394     try {
11395       result = (Dali::Quaternion *) &(arg1)->operator +=((Dali::Quaternion const &)*arg2);
11396     } catch (std::out_of_range& e) {
11397       {
11398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11399       };
11400     } catch (std::exception& e) {
11401       {
11402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11403       };
11404     } catch (Dali::DaliException e) {
11405       {
11406         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11407       };
11408     } catch (...) {
11409       {
11410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11411       };
11412     }
11413   }
11414
11415   jresult = (void *)result;
11416   return jresult;
11417 }
11418
11419
11420 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SubtractAssign(void * jarg1, void * jarg2) {
11421   void * jresult ;
11422   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11423   Dali::Quaternion *arg2 = 0 ;
11424   Dali::Quaternion *result = 0 ;
11425
11426   arg1 = (Dali::Quaternion *)jarg1;
11427   arg2 = (Dali::Quaternion *)jarg2;
11428   if (!arg2) {
11429     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11430     return 0;
11431   }
11432   {
11433     try {
11434       result = (Dali::Quaternion *) &(arg1)->operator -=((Dali::Quaternion const &)*arg2);
11435     } catch (std::out_of_range& e) {
11436       {
11437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11438       };
11439     } catch (std::exception& e) {
11440       {
11441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11442       };
11443     } catch (Dali::DaliException e) {
11444       {
11445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11446       };
11447     } catch (...) {
11448       {
11449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11450       };
11451     }
11452   }
11453
11454   jresult = (void *)result;
11455   return jresult;
11456 }
11457
11458
11459 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
11460   void * jresult ;
11461   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11462   Dali::Quaternion *arg2 = 0 ;
11463   Dali::Quaternion *result = 0 ;
11464
11465   arg1 = (Dali::Quaternion *)jarg1;
11466   arg2 = (Dali::Quaternion *)jarg2;
11467   if (!arg2) {
11468     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11469     return 0;
11470   }
11471   {
11472     try {
11473       result = (Dali::Quaternion *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
11474     } catch (std::out_of_range& e) {
11475       {
11476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11477       };
11478     } catch (std::exception& e) {
11479       {
11480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11481       };
11482     } catch (Dali::DaliException e) {
11483       {
11484         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11485       };
11486     } catch (...) {
11487       {
11488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11489       };
11490     }
11491   }
11492
11493   jresult = (void *)result;
11494   return jresult;
11495 }
11496
11497
11498 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
11499   void * jresult ;
11500   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11501   float arg2 ;
11502   Dali::Quaternion *result = 0 ;
11503
11504   arg1 = (Dali::Quaternion *)jarg1;
11505   arg2 = (float)jarg2;
11506   {
11507     try {
11508       result = (Dali::Quaternion *) &(arg1)->operator *=(arg2);
11509     } catch (std::out_of_range& e) {
11510       {
11511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11512       };
11513     } catch (std::exception& e) {
11514       {
11515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11516       };
11517     } catch (Dali::DaliException e) {
11518       {
11519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11520       };
11521     } catch (...) {
11522       {
11523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11524       };
11525     }
11526   }
11527
11528   jresult = (void *)result;
11529   return jresult;
11530 }
11531
11532
11533 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_DivideAssign(void * jarg1, float jarg2) {
11534   void * jresult ;
11535   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11536   float arg2 ;
11537   Dali::Quaternion *result = 0 ;
11538
11539   arg1 = (Dali::Quaternion *)jarg1;
11540   arg2 = (float)jarg2;
11541   {
11542     try {
11543       result = (Dali::Quaternion *) &(arg1)->operator /=(arg2);
11544     } catch (std::out_of_range& e) {
11545       {
11546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11547       };
11548     } catch (std::exception& e) {
11549       {
11550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11551       };
11552     } catch (Dali::DaliException e) {
11553       {
11554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11555       };
11556     } catch (...) {
11557       {
11558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11559       };
11560     }
11561   }
11562
11563   jresult = (void *)result;
11564   return jresult;
11565 }
11566
11567
11568 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_EqualTo(void * jarg1, void * jarg2) {
11569   unsigned int jresult ;
11570   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11571   Dali::Quaternion *arg2 = 0 ;
11572   bool result;
11573
11574   arg1 = (Dali::Quaternion *)jarg1;
11575   arg2 = (Dali::Quaternion *)jarg2;
11576   if (!arg2) {
11577     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11578     return 0;
11579   }
11580   {
11581     try {
11582       result = (bool)((Dali::Quaternion const *)arg1)->operator ==((Dali::Quaternion const &)*arg2);
11583     } catch (std::out_of_range& e) {
11584       {
11585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11586       };
11587     } catch (std::exception& e) {
11588       {
11589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11590       };
11591     } catch (Dali::DaliException e) {
11592       {
11593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11594       };
11595     } catch (...) {
11596       {
11597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11598       };
11599     }
11600   }
11601
11602   jresult = result;
11603   return jresult;
11604 }
11605
11606
11607 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_NotEqualTo(void * jarg1, void * jarg2) {
11608   unsigned int jresult ;
11609   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11610   Dali::Quaternion *arg2 = 0 ;
11611   bool result;
11612
11613   arg1 = (Dali::Quaternion *)jarg1;
11614   arg2 = (Dali::Quaternion *)jarg2;
11615   if (!arg2) {
11616     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11617     return 0;
11618   }
11619   {
11620     try {
11621       result = (bool)((Dali::Quaternion const *)arg1)->operator !=((Dali::Quaternion const &)*arg2);
11622     } catch (std::out_of_range& e) {
11623       {
11624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11625       };
11626     } catch (std::exception& e) {
11627       {
11628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11629       };
11630     } catch (Dali::DaliException e) {
11631       {
11632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11633       };
11634     } catch (...) {
11635       {
11636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11637       };
11638     }
11639   }
11640
11641   jresult = result;
11642   return jresult;
11643 }
11644
11645
11646 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Length(void * jarg1) {
11647   float jresult ;
11648   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11649   float result;
11650
11651   arg1 = (Dali::Quaternion *)jarg1;
11652   {
11653     try {
11654       result = (float)((Dali::Quaternion const *)arg1)->Length();
11655     } catch (std::out_of_range& e) {
11656       {
11657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11658       };
11659     } catch (std::exception& e) {
11660       {
11661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11662       };
11663     } catch (Dali::DaliException e) {
11664       {
11665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11666       };
11667     } catch (...) {
11668       {
11669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11670       };
11671     }
11672   }
11673
11674   jresult = result;
11675   return jresult;
11676 }
11677
11678
11679 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_LengthSquared(void * jarg1) {
11680   float jresult ;
11681   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11682   float result;
11683
11684   arg1 = (Dali::Quaternion *)jarg1;
11685   {
11686     try {
11687       result = (float)((Dali::Quaternion const *)arg1)->LengthSquared();
11688     } catch (std::out_of_range& e) {
11689       {
11690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11691       };
11692     } catch (std::exception& e) {
11693       {
11694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11695       };
11696     } catch (Dali::DaliException e) {
11697       {
11698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11699       };
11700     } catch (...) {
11701       {
11702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11703       };
11704     }
11705   }
11706
11707   jresult = result;
11708   return jresult;
11709 }
11710
11711
11712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Normalize(void * jarg1) {
11713   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11714
11715   arg1 = (Dali::Quaternion *)jarg1;
11716   {
11717     try {
11718       (arg1)->Normalize();
11719     } catch (std::out_of_range& e) {
11720       {
11721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11722       };
11723     } catch (std::exception& e) {
11724       {
11725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11726       };
11727     } catch (Dali::DaliException e) {
11728       {
11729         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11730       };
11731     } catch (...) {
11732       {
11733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11734       };
11735     }
11736   }
11737
11738 }
11739
11740
11741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Normalized(void * jarg1) {
11742   void * jresult ;
11743   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11744   Dali::Quaternion result;
11745
11746   arg1 = (Dali::Quaternion *)jarg1;
11747   {
11748     try {
11749       result = ((Dali::Quaternion const *)arg1)->Normalized();
11750     } catch (std::out_of_range& e) {
11751       {
11752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11753       };
11754     } catch (std::exception& e) {
11755       {
11756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11757       };
11758     } catch (Dali::DaliException e) {
11759       {
11760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11761       };
11762     } catch (...) {
11763       {
11764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11765       };
11766     }
11767   }
11768
11769   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11770   return jresult;
11771 }
11772
11773
11774 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Conjugate(void * jarg1) {
11775   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11776
11777   arg1 = (Dali::Quaternion *)jarg1;
11778   {
11779     try {
11780       (arg1)->Conjugate();
11781     } catch (std::out_of_range& e) {
11782       {
11783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11784       };
11785     } catch (std::exception& e) {
11786       {
11787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11788       };
11789     } catch (Dali::DaliException e) {
11790       {
11791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11792       };
11793     } catch (...) {
11794       {
11795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11796       };
11797     }
11798   }
11799
11800 }
11801
11802
11803 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Invert(void * jarg1) {
11804   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11805
11806   arg1 = (Dali::Quaternion *)jarg1;
11807   {
11808     try {
11809       (arg1)->Invert();
11810     } catch (std::out_of_range& e) {
11811       {
11812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11813       };
11814     } catch (std::exception& e) {
11815       {
11816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11817       };
11818     } catch (Dali::DaliException e) {
11819       {
11820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11821       };
11822     } catch (...) {
11823       {
11824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11825       };
11826     }
11827   }
11828
11829 }
11830
11831
11832 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Log(void * jarg1) {
11833   void * jresult ;
11834   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11835   Dali::Quaternion result;
11836
11837   arg1 = (Dali::Quaternion *)jarg1;
11838   {
11839     try {
11840       result = ((Dali::Quaternion const *)arg1)->Log();
11841     } catch (std::out_of_range& e) {
11842       {
11843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11844       };
11845     } catch (std::exception& e) {
11846       {
11847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11848       };
11849     } catch (Dali::DaliException e) {
11850       {
11851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11852       };
11853     } catch (...) {
11854       {
11855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11856       };
11857     }
11858   }
11859
11860   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11861   return jresult;
11862 }
11863
11864
11865 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Exp(void * jarg1) {
11866   void * jresult ;
11867   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11868   Dali::Quaternion result;
11869
11870   arg1 = (Dali::Quaternion *)jarg1;
11871   {
11872     try {
11873       result = ((Dali::Quaternion const *)arg1)->Exp();
11874     } catch (std::out_of_range& e) {
11875       {
11876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11877       };
11878     } catch (std::exception& e) {
11879       {
11880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11881       };
11882     } catch (Dali::DaliException e) {
11883       {
11884         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11885       };
11886     } catch (...) {
11887       {
11888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11889       };
11890     }
11891   }
11892
11893   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11894   return jresult;
11895 }
11896
11897
11898 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Dot(void * jarg1, void * jarg2) {
11899   float jresult ;
11900   Dali::Quaternion *arg1 = 0 ;
11901   Dali::Quaternion *arg2 = 0 ;
11902   float result;
11903
11904   arg1 = (Dali::Quaternion *)jarg1;
11905   if (!arg1) {
11906     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11907     return 0;
11908   }
11909   arg2 = (Dali::Quaternion *)jarg2;
11910   if (!arg2) {
11911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11912     return 0;
11913   }
11914   {
11915     try {
11916       result = (float)Dali::Quaternion::Dot((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
11917     } catch (std::out_of_range& e) {
11918       {
11919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11920       };
11921     } catch (std::exception& e) {
11922       {
11923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11924       };
11925     } catch (Dali::DaliException e) {
11926       {
11927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11928       };
11929     } catch (...) {
11930       {
11931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11932       };
11933     }
11934   }
11935
11936   jresult = result;
11937   return jresult;
11938 }
11939
11940
11941 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Lerp(void * jarg1, void * jarg2, float jarg3) {
11942   void * jresult ;
11943   Dali::Quaternion *arg1 = 0 ;
11944   Dali::Quaternion *arg2 = 0 ;
11945   float arg3 ;
11946   Dali::Quaternion result;
11947
11948   arg1 = (Dali::Quaternion *)jarg1;
11949   if (!arg1) {
11950     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11951     return 0;
11952   }
11953   arg2 = (Dali::Quaternion *)jarg2;
11954   if (!arg2) {
11955     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11956     return 0;
11957   }
11958   arg3 = (float)jarg3;
11959   {
11960     try {
11961       result = Dali::Quaternion::Lerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
11962     } catch (std::out_of_range& e) {
11963       {
11964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11965       };
11966     } catch (std::exception& e) {
11967       {
11968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11969       };
11970     } catch (Dali::DaliException e) {
11971       {
11972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11973       };
11974     } catch (...) {
11975       {
11976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11977       };
11978     }
11979   }
11980
11981   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11982   return jresult;
11983 }
11984
11985
11986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Slerp(void * jarg1, void * jarg2, float jarg3) {
11987   void * jresult ;
11988   Dali::Quaternion *arg1 = 0 ;
11989   Dali::Quaternion *arg2 = 0 ;
11990   float arg3 ;
11991   Dali::Quaternion result;
11992
11993   arg1 = (Dali::Quaternion *)jarg1;
11994   if (!arg1) {
11995     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11996     return 0;
11997   }
11998   arg2 = (Dali::Quaternion *)jarg2;
11999   if (!arg2) {
12000     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12001     return 0;
12002   }
12003   arg3 = (float)jarg3;
12004   {
12005     try {
12006       result = Dali::Quaternion::Slerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
12007     } catch (std::out_of_range& e) {
12008       {
12009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12010       };
12011     } catch (std::exception& e) {
12012       {
12013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12014       };
12015     } catch (Dali::DaliException e) {
12016       {
12017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12018       };
12019     } catch (...) {
12020       {
12021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12022       };
12023     }
12024   }
12025
12026   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
12027   return jresult;
12028 }
12029
12030
12031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SlerpNoInvert(void * jarg1, void * jarg2, float jarg3) {
12032   void * jresult ;
12033   Dali::Quaternion *arg1 = 0 ;
12034   Dali::Quaternion *arg2 = 0 ;
12035   float arg3 ;
12036   Dali::Quaternion result;
12037
12038   arg1 = (Dali::Quaternion *)jarg1;
12039   if (!arg1) {
12040     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12041     return 0;
12042   }
12043   arg2 = (Dali::Quaternion *)jarg2;
12044   if (!arg2) {
12045     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12046     return 0;
12047   }
12048   arg3 = (float)jarg3;
12049   {
12050     try {
12051       result = Dali::Quaternion::SlerpNoInvert((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
12052     } catch (std::out_of_range& e) {
12053       {
12054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12055       };
12056     } catch (std::exception& e) {
12057       {
12058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12059       };
12060     } catch (Dali::DaliException e) {
12061       {
12062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12063       };
12064     } catch (...) {
12065       {
12066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12067       };
12068     }
12069   }
12070
12071   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
12072   return jresult;
12073 }
12074
12075
12076 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Squad(void * jarg1, void * jarg2, void * jarg3, void * jarg4, float jarg5) {
12077   void * jresult ;
12078   Dali::Quaternion *arg1 = 0 ;
12079   Dali::Quaternion *arg2 = 0 ;
12080   Dali::Quaternion *arg3 = 0 ;
12081   Dali::Quaternion *arg4 = 0 ;
12082   float arg5 ;
12083   Dali::Quaternion result;
12084
12085   arg1 = (Dali::Quaternion *)jarg1;
12086   if (!arg1) {
12087     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12088     return 0;
12089   }
12090   arg2 = (Dali::Quaternion *)jarg2;
12091   if (!arg2) {
12092     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12093     return 0;
12094   }
12095   arg3 = (Dali::Quaternion *)jarg3;
12096   if (!arg3) {
12097     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12098     return 0;
12099   }
12100   arg4 = (Dali::Quaternion *)jarg4;
12101   if (!arg4) {
12102     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12103     return 0;
12104   }
12105   arg5 = (float)jarg5;
12106   {
12107     try {
12108       result = Dali::Quaternion::Squad((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Quaternion const &)*arg4,arg5);
12109     } catch (std::out_of_range& e) {
12110       {
12111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12112       };
12113     } catch (std::exception& e) {
12114       {
12115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12116       };
12117     } catch (Dali::DaliException e) {
12118       {
12119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12120       };
12121     } catch (...) {
12122       {
12123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12124       };
12125     }
12126   }
12127
12128   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
12129   return jresult;
12130 }
12131
12132
12133 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_AngleBetween(void * jarg1, void * jarg2) {
12134   float jresult ;
12135   Dali::Quaternion *arg1 = 0 ;
12136   Dali::Quaternion *arg2 = 0 ;
12137   float result;
12138
12139   arg1 = (Dali::Quaternion *)jarg1;
12140   if (!arg1) {
12141     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12142     return 0;
12143   }
12144   arg2 = (Dali::Quaternion *)jarg2;
12145   if (!arg2) {
12146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12147     return 0;
12148   }
12149   {
12150     try {
12151       result = (float)Dali::Quaternion::AngleBetween((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
12152     } catch (std::out_of_range& e) {
12153       {
12154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12155       };
12156     } catch (std::exception& e) {
12157       {
12158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12159       };
12160     } catch (Dali::DaliException e) {
12161       {
12162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12163       };
12164     } catch (...) {
12165       {
12166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12167       };
12168     }
12169   }
12170
12171   jresult = result;
12172   return jresult;
12173 }
12174
12175
12176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_0() {
12177   void * jresult ;
12178   Dali::Matrix *result = 0 ;
12179
12180   {
12181     try {
12182       result = (Dali::Matrix *)new Dali::Matrix();
12183     } catch (std::out_of_range& e) {
12184       {
12185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12186       };
12187     } catch (std::exception& e) {
12188       {
12189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12190       };
12191     } catch (Dali::DaliException e) {
12192       {
12193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12194       };
12195     } catch (...) {
12196       {
12197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12198       };
12199     }
12200   }
12201
12202   jresult = (void *)result;
12203   return jresult;
12204 }
12205
12206
12207 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_1(unsigned int jarg1) {
12208   void * jresult ;
12209   bool arg1 ;
12210   Dali::Matrix *result = 0 ;
12211
12212   arg1 = jarg1 ? true : false;
12213   {
12214     try {
12215       result = (Dali::Matrix *)new Dali::Matrix(arg1);
12216     } catch (std::out_of_range& e) {
12217       {
12218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12219       };
12220     } catch (std::exception& e) {
12221       {
12222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12223       };
12224     } catch (Dali::DaliException e) {
12225       {
12226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12227       };
12228     } catch (...) {
12229       {
12230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12231       };
12232     }
12233   }
12234
12235   jresult = (void *)result;
12236   return jresult;
12237 }
12238
12239
12240 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_2(float* jarg1) {
12241   void * jresult ;
12242   float *arg1 = (float *) 0 ;
12243   Dali::Matrix *result = 0 ;
12244
12245   arg1 = jarg1;
12246   {
12247     try {
12248       result = (Dali::Matrix *)new Dali::Matrix((float const *)arg1);
12249     } catch (std::out_of_range& e) {
12250       {
12251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12252       };
12253     } catch (std::exception& e) {
12254       {
12255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12256       };
12257     } catch (Dali::DaliException e) {
12258       {
12259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12260       };
12261     } catch (...) {
12262       {
12263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12264       };
12265     }
12266   }
12267
12268   jresult = (void *)result;
12269
12270
12271   return jresult;
12272 }
12273
12274
12275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_3(void * jarg1) {
12276   void * jresult ;
12277   Dali::Quaternion *arg1 = 0 ;
12278   Dali::Matrix *result = 0 ;
12279
12280   arg1 = (Dali::Quaternion *)jarg1;
12281   if (!arg1) {
12282     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12283     return 0;
12284   }
12285   {
12286     try {
12287       result = (Dali::Matrix *)new Dali::Matrix((Dali::Quaternion const &)*arg1);
12288     } catch (std::out_of_range& e) {
12289       {
12290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12291       };
12292     } catch (std::exception& e) {
12293       {
12294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12295       };
12296     } catch (Dali::DaliException e) {
12297       {
12298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12299       };
12300     } catch (...) {
12301       {
12302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12303       };
12304     }
12305   }
12306
12307   jresult = (void *)result;
12308   return jresult;
12309 }
12310
12311
12312 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_4(void * jarg1) {
12313   void * jresult ;
12314   Dali::Matrix *arg1 = 0 ;
12315   Dali::Matrix *result = 0 ;
12316
12317   arg1 = (Dali::Matrix *)jarg1;
12318   if (!arg1) {
12319     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12320     return 0;
12321   }
12322   {
12323     try {
12324       result = (Dali::Matrix *)new Dali::Matrix((Dali::Matrix const &)*arg1);
12325     } catch (std::out_of_range& e) {
12326       {
12327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12328       };
12329     } catch (std::exception& e) {
12330       {
12331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12332       };
12333     } catch (Dali::DaliException e) {
12334       {
12335         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12336       };
12337     } catch (...) {
12338       {
12339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12340       };
12341     }
12342   }
12343
12344   jresult = (void *)result;
12345   return jresult;
12346 }
12347
12348
12349 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Assign(void * jarg1, void * jarg2) {
12350   void * jresult ;
12351   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12352   Dali::Matrix *arg2 = 0 ;
12353   Dali::Matrix *result = 0 ;
12354
12355   arg1 = (Dali::Matrix *)jarg1;
12356   arg2 = (Dali::Matrix *)jarg2;
12357   if (!arg2) {
12358     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12359     return 0;
12360   }
12361   {
12362     try {
12363       result = (Dali::Matrix *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
12364     } catch (std::out_of_range& e) {
12365       {
12366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12367       };
12368     } catch (std::exception& e) {
12369       {
12370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12371       };
12372     } catch (Dali::DaliException e) {
12373       {
12374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12375       };
12376     } catch (...) {
12377       {
12378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12379       };
12380     }
12381   }
12382
12383   jresult = (void *)result;
12384   return jresult;
12385 }
12386
12387
12388 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_IDENTITY_get() {
12389   void * jresult ;
12390   Dali::Matrix *result = 0 ;
12391
12392   result = (Dali::Matrix *)&Dali::Matrix::IDENTITY;
12393   jresult = (void *)result;
12394   return jresult;
12395 }
12396
12397
12398 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentity(void * jarg1) {
12399   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12400
12401   arg1 = (Dali::Matrix *)jarg1;
12402   {
12403     try {
12404       (arg1)->SetIdentity();
12405     } catch (std::out_of_range& e) {
12406       {
12407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12408       };
12409     } catch (std::exception& e) {
12410       {
12411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12412       };
12413     } catch (Dali::DaliException e) {
12414       {
12415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12416       };
12417     } catch (...) {
12418       {
12419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12420       };
12421     }
12422   }
12423
12424 }
12425
12426
12427 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentityAndScale(void * jarg1, void * jarg2) {
12428   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12429   Dali::Vector3 *arg2 = 0 ;
12430
12431   arg1 = (Dali::Matrix *)jarg1;
12432   arg2 = (Dali::Vector3 *)jarg2;
12433   if (!arg2) {
12434     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12435     return ;
12436   }
12437   {
12438     try {
12439       (arg1)->SetIdentityAndScale((Dali::Vector3 const &)*arg2);
12440     } catch (std::out_of_range& e) {
12441       {
12442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12443       };
12444     } catch (std::exception& e) {
12445       {
12446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12447       };
12448     } catch (Dali::DaliException e) {
12449       {
12450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12451       };
12452     } catch (...) {
12453       {
12454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12455       };
12456     }
12457   }
12458
12459 }
12460
12461
12462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_InvertTransform(void * jarg1, void * jarg2) {
12463   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12464   Dali::Matrix *arg2 = 0 ;
12465
12466   arg1 = (Dali::Matrix *)jarg1;
12467   arg2 = (Dali::Matrix *)jarg2;
12468   if (!arg2) {
12469     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
12470     return ;
12471   }
12472   {
12473     try {
12474       ((Dali::Matrix const *)arg1)->InvertTransform(*arg2);
12475     } catch (std::out_of_range& e) {
12476       {
12477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12478       };
12479     } catch (std::exception& e) {
12480       {
12481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12482       };
12483     } catch (Dali::DaliException e) {
12484       {
12485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12486       };
12487     } catch (...) {
12488       {
12489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12490       };
12491     }
12492   }
12493
12494 }
12495
12496
12497 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_Invert(void * jarg1) {
12498   unsigned int jresult ;
12499   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12500   bool result;
12501
12502   arg1 = (Dali::Matrix *)jarg1;
12503   {
12504     try {
12505       result = (bool)(arg1)->Invert();
12506     } catch (std::out_of_range& e) {
12507       {
12508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12509       };
12510     } catch (std::exception& e) {
12511       {
12512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12513       };
12514     } catch (Dali::DaliException e) {
12515       {
12516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12517       };
12518     } catch (...) {
12519       {
12520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12521       };
12522     }
12523   }
12524
12525   jresult = result;
12526   return jresult;
12527 }
12528
12529
12530 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Transpose(void * jarg1) {
12531   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12532
12533   arg1 = (Dali::Matrix *)jarg1;
12534   {
12535     try {
12536       (arg1)->Transpose();
12537     } catch (std::out_of_range& e) {
12538       {
12539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12540       };
12541     } catch (std::exception& e) {
12542       {
12543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12544       };
12545     } catch (Dali::DaliException e) {
12546       {
12547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12548       };
12549     } catch (...) {
12550       {
12551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12552       };
12553     }
12554   }
12555
12556 }
12557
12558
12559 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetXAxis(void * jarg1) {
12560   void * jresult ;
12561   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12562   Dali::Vector3 result;
12563
12564   arg1 = (Dali::Matrix *)jarg1;
12565   {
12566     try {
12567       result = ((Dali::Matrix const *)arg1)->GetXAxis();
12568     } catch (std::out_of_range& e) {
12569       {
12570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12571       };
12572     } catch (std::exception& e) {
12573       {
12574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12575       };
12576     } catch (Dali::DaliException e) {
12577       {
12578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12579       };
12580     } catch (...) {
12581       {
12582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12583       };
12584     }
12585   }
12586
12587   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12588   return jresult;
12589 }
12590
12591
12592 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetYAxis(void * jarg1) {
12593   void * jresult ;
12594   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12595   Dali::Vector3 result;
12596
12597   arg1 = (Dali::Matrix *)jarg1;
12598   {
12599     try {
12600       result = ((Dali::Matrix const *)arg1)->GetYAxis();
12601     } catch (std::out_of_range& e) {
12602       {
12603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12604       };
12605     } catch (std::exception& e) {
12606       {
12607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12608       };
12609     } catch (Dali::DaliException e) {
12610       {
12611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12612       };
12613     } catch (...) {
12614       {
12615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12616       };
12617     }
12618   }
12619
12620   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12621   return jresult;
12622 }
12623
12624
12625 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetZAxis(void * jarg1) {
12626   void * jresult ;
12627   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12628   Dali::Vector3 result;
12629
12630   arg1 = (Dali::Matrix *)jarg1;
12631   {
12632     try {
12633       result = ((Dali::Matrix const *)arg1)->GetZAxis();
12634     } catch (std::out_of_range& e) {
12635       {
12636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12637       };
12638     } catch (std::exception& e) {
12639       {
12640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12641       };
12642     } catch (Dali::DaliException e) {
12643       {
12644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12645       };
12646     } catch (...) {
12647       {
12648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12649       };
12650     }
12651   }
12652
12653   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12654   return jresult;
12655 }
12656
12657
12658 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetXAxis(void * jarg1, void * jarg2) {
12659   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12660   Dali::Vector3 *arg2 = 0 ;
12661
12662   arg1 = (Dali::Matrix *)jarg1;
12663   arg2 = (Dali::Vector3 *)jarg2;
12664   if (!arg2) {
12665     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12666     return ;
12667   }
12668   {
12669     try {
12670       (arg1)->SetXAxis((Dali::Vector3 const &)*arg2);
12671     } catch (std::out_of_range& e) {
12672       {
12673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12674       };
12675     } catch (std::exception& e) {
12676       {
12677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12678       };
12679     } catch (Dali::DaliException e) {
12680       {
12681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12682       };
12683     } catch (...) {
12684       {
12685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12686       };
12687     }
12688   }
12689
12690 }
12691
12692
12693 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetYAxis(void * jarg1, void * jarg2) {
12694   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12695   Dali::Vector3 *arg2 = 0 ;
12696
12697   arg1 = (Dali::Matrix *)jarg1;
12698   arg2 = (Dali::Vector3 *)jarg2;
12699   if (!arg2) {
12700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12701     return ;
12702   }
12703   {
12704     try {
12705       (arg1)->SetYAxis((Dali::Vector3 const &)*arg2);
12706     } catch (std::out_of_range& e) {
12707       {
12708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12709       };
12710     } catch (std::exception& e) {
12711       {
12712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12713       };
12714     } catch (Dali::DaliException e) {
12715       {
12716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12717       };
12718     } catch (...) {
12719       {
12720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12721       };
12722     }
12723   }
12724
12725 }
12726
12727
12728 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetZAxis(void * jarg1, void * jarg2) {
12729   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12730   Dali::Vector3 *arg2 = 0 ;
12731
12732   arg1 = (Dali::Matrix *)jarg1;
12733   arg2 = (Dali::Vector3 *)jarg2;
12734   if (!arg2) {
12735     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12736     return ;
12737   }
12738   {
12739     try {
12740       (arg1)->SetZAxis((Dali::Vector3 const &)*arg2);
12741     } catch (std::out_of_range& e) {
12742       {
12743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12744       };
12745     } catch (std::exception& e) {
12746       {
12747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12748       };
12749     } catch (Dali::DaliException e) {
12750       {
12751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12752       };
12753     } catch (...) {
12754       {
12755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12756       };
12757     }
12758   }
12759
12760 }
12761
12762
12763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation(void * jarg1) {
12764   void * jresult ;
12765   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12766   Dali::Vector4 *result = 0 ;
12767
12768   arg1 = (Dali::Matrix *)jarg1;
12769   {
12770     try {
12771       result = (Dali::Vector4 *) &((Dali::Matrix const *)arg1)->GetTranslation();
12772     } catch (std::out_of_range& e) {
12773       {
12774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12775       };
12776     } catch (std::exception& e) {
12777       {
12778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12779       };
12780     } catch (Dali::DaliException e) {
12781       {
12782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12783       };
12784     } catch (...) {
12785       {
12786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12787       };
12788     }
12789   }
12790
12791   jresult = (void *)result;
12792   return jresult;
12793 }
12794
12795
12796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation3(void * jarg1) {
12797   void * jresult ;
12798   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12799   Dali::Vector3 *result = 0 ;
12800
12801   arg1 = (Dali::Matrix *)jarg1;
12802   {
12803     try {
12804       result = (Dali::Vector3 *) &((Dali::Matrix const *)arg1)->GetTranslation3();
12805     } catch (std::out_of_range& e) {
12806       {
12807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12808       };
12809     } catch (std::exception& e) {
12810       {
12811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12812       };
12813     } catch (Dali::DaliException e) {
12814       {
12815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12816       };
12817     } catch (...) {
12818       {
12819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12820       };
12821     }
12822   }
12823
12824   jresult = (void *)result;
12825   return jresult;
12826 }
12827
12828
12829 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_0(void * jarg1, void * jarg2) {
12830   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12831   Dali::Vector4 *arg2 = 0 ;
12832
12833   arg1 = (Dali::Matrix *)jarg1;
12834   arg2 = (Dali::Vector4 *)jarg2;
12835   if (!arg2) {
12836     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
12837     return ;
12838   }
12839   {
12840     try {
12841       (arg1)->SetTranslation((Dali::Vector4 const &)*arg2);
12842     } catch (std::out_of_range& e) {
12843       {
12844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12845       };
12846     } catch (std::exception& e) {
12847       {
12848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12849       };
12850     } catch (Dali::DaliException e) {
12851       {
12852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12853       };
12854     } catch (...) {
12855       {
12856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12857       };
12858     }
12859   }
12860
12861 }
12862
12863
12864 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_1(void * jarg1, void * jarg2) {
12865   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12866   Dali::Vector3 *arg2 = 0 ;
12867
12868   arg1 = (Dali::Matrix *)jarg1;
12869   arg2 = (Dali::Vector3 *)jarg2;
12870   if (!arg2) {
12871     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12872     return ;
12873   }
12874   {
12875     try {
12876       (arg1)->SetTranslation((Dali::Vector3 const &)*arg2);
12877     } catch (std::out_of_range& e) {
12878       {
12879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12880       };
12881     } catch (std::exception& e) {
12882       {
12883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12884       };
12885     } catch (Dali::DaliException e) {
12886       {
12887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12888       };
12889     } catch (...) {
12890       {
12891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12892       };
12893     }
12894   }
12895
12896 }
12897
12898
12899 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_OrthoNormalize(void * jarg1) {
12900   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12901
12902   arg1 = (Dali::Matrix *)jarg1;
12903   {
12904     try {
12905       (arg1)->OrthoNormalize();
12906     } catch (std::out_of_range& e) {
12907       {
12908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12909       };
12910     } catch (std::exception& e) {
12911       {
12912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12913       };
12914     } catch (Dali::DaliException e) {
12915       {
12916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12917       };
12918     } catch (...) {
12919       {
12920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12921       };
12922     }
12923   }
12924
12925 }
12926
12927
12928 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_AsFloat__SWIG_0(void * jarg1) {
12929   void * jresult ;
12930   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12931   float *result = 0 ;
12932
12933   arg1 = (Dali::Matrix *)jarg1;
12934   {
12935     try {
12936       result = (float *)((Dali::Matrix const *)arg1)->AsFloat();
12937     } catch (std::out_of_range& e) {
12938       {
12939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12940       };
12941     } catch (std::exception& e) {
12942       {
12943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12944       };
12945     } catch (Dali::DaliException e) {
12946       {
12947         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12948       };
12949     } catch (...) {
12950       {
12951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12952       };
12953     }
12954   }
12955
12956   jresult = (void *)result;
12957   return jresult;
12958 }
12959
12960
12961 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
12962   Dali::Matrix *arg1 = 0 ;
12963   Dali::Matrix *arg2 = 0 ;
12964   Dali::Matrix *arg3 = 0 ;
12965
12966   arg1 = (Dali::Matrix *)jarg1;
12967   if (!arg1) {
12968     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
12969     return ;
12970   }
12971   arg2 = (Dali::Matrix *)jarg2;
12972   if (!arg2) {
12973     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12974     return ;
12975   }
12976   arg3 = (Dali::Matrix *)jarg3;
12977   if (!arg3) {
12978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12979     return ;
12980   }
12981   {
12982     try {
12983       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Matrix const &)*arg3);
12984     } catch (std::out_of_range& e) {
12985       {
12986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12987       };
12988     } catch (std::exception& e) {
12989       {
12990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12991       };
12992     } catch (Dali::DaliException e) {
12993       {
12994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12995       };
12996     } catch (...) {
12997       {
12998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12999       };
13000     }
13001   }
13002
13003 }
13004
13005
13006 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
13007   Dali::Matrix *arg1 = 0 ;
13008   Dali::Matrix *arg2 = 0 ;
13009   Dali::Quaternion *arg3 = 0 ;
13010
13011   arg1 = (Dali::Matrix *)jarg1;
13012   if (!arg1) {
13013     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
13014     return ;
13015   }
13016   arg2 = (Dali::Matrix *)jarg2;
13017   if (!arg2) {
13018     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13019     return ;
13020   }
13021   arg3 = (Dali::Quaternion *)jarg3;
13022   if (!arg3) {
13023     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
13024     return ;
13025   }
13026   {
13027     try {
13028       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Quaternion const &)*arg3);
13029     } catch (std::out_of_range& e) {
13030       {
13031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13032       };
13033     } catch (std::exception& e) {
13034       {
13035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13036       };
13037     } catch (Dali::DaliException e) {
13038       {
13039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13040       };
13041     } catch (...) {
13042       {
13043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13044       };
13045     }
13046   }
13047
13048 }
13049
13050
13051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_2(void * jarg1, void * jarg2) {
13052   void * jresult ;
13053   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13054   Dali::Vector4 *arg2 = 0 ;
13055   Dali::Vector4 result;
13056
13057   arg1 = (Dali::Matrix *)jarg1;
13058   arg2 = (Dali::Vector4 *)jarg2;
13059   if (!arg2) {
13060     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
13061     return 0;
13062   }
13063   {
13064     try {
13065       result = ((Dali::Matrix const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
13066     } catch (std::out_of_range& e) {
13067       {
13068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13069       };
13070     } catch (std::exception& e) {
13071       {
13072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13073       };
13074     } catch (Dali::DaliException e) {
13075       {
13076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13077       };
13078     } catch (...) {
13079       {
13080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13081       };
13082     }
13083   }
13084
13085   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
13086   return jresult;
13087 }
13088
13089
13090 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_EqualTo(void * jarg1, void * jarg2) {
13091   unsigned int jresult ;
13092   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13093   Dali::Matrix *arg2 = 0 ;
13094   bool result;
13095
13096   arg1 = (Dali::Matrix *)jarg1;
13097   arg2 = (Dali::Matrix *)jarg2;
13098   if (!arg2) {
13099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13100     return 0;
13101   }
13102   {
13103     try {
13104       result = (bool)((Dali::Matrix const *)arg1)->operator ==((Dali::Matrix const &)*arg2);
13105     } catch (std::out_of_range& e) {
13106       {
13107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13108       };
13109     } catch (std::exception& e) {
13110       {
13111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13112       };
13113     } catch (Dali::DaliException e) {
13114       {
13115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13116       };
13117     } catch (...) {
13118       {
13119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13120       };
13121     }
13122   }
13123
13124   jresult = result;
13125   return jresult;
13126 }
13127
13128
13129 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_NotEqualTo(void * jarg1, void * jarg2) {
13130   unsigned int jresult ;
13131   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13132   Dali::Matrix *arg2 = 0 ;
13133   bool result;
13134
13135   arg1 = (Dali::Matrix *)jarg1;
13136   arg2 = (Dali::Matrix *)jarg2;
13137   if (!arg2) {
13138     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13139     return 0;
13140   }
13141   {
13142     try {
13143       result = (bool)((Dali::Matrix const *)arg1)->operator !=((Dali::Matrix const &)*arg2);
13144     } catch (std::out_of_range& e) {
13145       {
13146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13147       };
13148     } catch (std::exception& e) {
13149       {
13150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13151       };
13152     } catch (Dali::DaliException e) {
13153       {
13154         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13155       };
13156     } catch (...) {
13157       {
13158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13159       };
13160     }
13161   }
13162
13163   jresult = result;
13164   return jresult;
13165 }
13166
13167
13168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13169   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13170   Dali::Vector3 *arg2 = 0 ;
13171   Dali::Quaternion *arg3 = 0 ;
13172   Dali::Vector3 *arg4 = 0 ;
13173
13174   arg1 = (Dali::Matrix *)jarg1;
13175   arg2 = (Dali::Vector3 *)jarg2;
13176   if (!arg2) {
13177     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13178     return ;
13179   }
13180   arg3 = (Dali::Quaternion *)jarg3;
13181   if (!arg3) {
13182     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
13183     return ;
13184   }
13185   arg4 = (Dali::Vector3 *)jarg4;
13186   if (!arg4) {
13187     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13188     return ;
13189   }
13190   {
13191     try {
13192       (arg1)->SetTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
13193     } catch (std::out_of_range& e) {
13194       {
13195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13196       };
13197     } catch (std::exception& e) {
13198       {
13199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13200       };
13201     } catch (Dali::DaliException e) {
13202       {
13203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13204       };
13205     } catch (...) {
13206       {
13207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13208       };
13209     }
13210   }
13211
13212 }
13213
13214
13215 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13216   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13217   Dali::Vector3 *arg2 = 0 ;
13218   Dali::Quaternion *arg3 = 0 ;
13219   Dali::Vector3 *arg4 = 0 ;
13220
13221   arg1 = (Dali::Matrix *)jarg1;
13222   arg2 = (Dali::Vector3 *)jarg2;
13223   if (!arg2) {
13224     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13225     return ;
13226   }
13227   arg3 = (Dali::Quaternion *)jarg3;
13228   if (!arg3) {
13229     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
13230     return ;
13231   }
13232   arg4 = (Dali::Vector3 *)jarg4;
13233   if (!arg4) {
13234     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13235     return ;
13236   }
13237   {
13238     try {
13239       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
13240     } catch (std::out_of_range& e) {
13241       {
13242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13243       };
13244     } catch (std::exception& e) {
13245       {
13246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13247       };
13248     } catch (Dali::DaliException e) {
13249       {
13250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13251       };
13252     } catch (...) {
13253       {
13254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13255       };
13256     }
13257   }
13258
13259 }
13260
13261
13262 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
13263   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13264   Dali::Vector3 *arg2 = 0 ;
13265   Dali::Vector3 *arg3 = 0 ;
13266   Dali::Vector3 *arg4 = 0 ;
13267   Dali::Vector3 *arg5 = 0 ;
13268
13269   arg1 = (Dali::Matrix *)jarg1;
13270   arg2 = (Dali::Vector3 *)jarg2;
13271   if (!arg2) {
13272     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13273     return ;
13274   }
13275   arg3 = (Dali::Vector3 *)jarg3;
13276   if (!arg3) {
13277     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13278     return ;
13279   }
13280   arg4 = (Dali::Vector3 *)jarg4;
13281   if (!arg4) {
13282     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13283     return ;
13284   }
13285   arg5 = (Dali::Vector3 *)jarg5;
13286   if (!arg5) {
13287     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13288     return ;
13289   }
13290   {
13291     try {
13292       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3,(Dali::Vector3 const &)*arg4,(Dali::Vector3 const &)*arg5);
13293     } catch (std::out_of_range& e) {
13294       {
13295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13296       };
13297     } catch (std::exception& e) {
13298       {
13299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13300       };
13301     } catch (Dali::DaliException e) {
13302       {
13303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13304       };
13305     } catch (...) {
13306       {
13307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13308       };
13309     }
13310   }
13311
13312 }
13313
13314
13315 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_GetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13316   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13317   Dali::Vector3 *arg2 = 0 ;
13318   Dali::Quaternion *arg3 = 0 ;
13319   Dali::Vector3 *arg4 = 0 ;
13320
13321   arg1 = (Dali::Matrix *)jarg1;
13322   arg2 = (Dali::Vector3 *)jarg2;
13323   if (!arg2) {
13324     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
13325     return ;
13326   }
13327   arg3 = (Dali::Quaternion *)jarg3;
13328   if (!arg3) {
13329     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
13330     return ;
13331   }
13332   arg4 = (Dali::Vector3 *)jarg4;
13333   if (!arg4) {
13334     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
13335     return ;
13336   }
13337   {
13338     try {
13339       ((Dali::Matrix const *)arg1)->GetTransformComponents(*arg2,*arg3,*arg4);
13340     } catch (std::out_of_range& e) {
13341       {
13342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13343       };
13344     } catch (std::exception& e) {
13345       {
13346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13347       };
13348     } catch (Dali::DaliException e) {
13349       {
13350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13351       };
13352     } catch (...) {
13353       {
13354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13355       };
13356     }
13357   }
13358
13359 }
13360
13361
13362 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix(void * jarg1) {
13363   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13364
13365   arg1 = (Dali::Matrix *)jarg1;
13366   {
13367     try {
13368       delete arg1;
13369     } catch (std::out_of_range& e) {
13370       {
13371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13372       };
13373     } catch (std::exception& e) {
13374       {
13375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13376       };
13377     } catch (Dali::DaliException e) {
13378       {
13379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13380       };
13381     } catch (...) {
13382       {
13383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13384       };
13385     }
13386   }
13387
13388 }
13389
13390
13391 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_IDENTITY_get() {
13392   void * jresult ;
13393   Dali::Matrix3 *result = 0 ;
13394
13395   result = (Dali::Matrix3 *)&Dali::Matrix3::IDENTITY;
13396   jresult = (void *)result;
13397   return jresult;
13398 }
13399
13400
13401 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_0() {
13402   void * jresult ;
13403   Dali::Matrix3 *result = 0 ;
13404
13405   {
13406     try {
13407       result = (Dali::Matrix3 *)new Dali::Matrix3();
13408     } catch (std::out_of_range& e) {
13409       {
13410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13411       };
13412     } catch (std::exception& e) {
13413       {
13414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13415       };
13416     } catch (Dali::DaliException e) {
13417       {
13418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13419       };
13420     } catch (...) {
13421       {
13422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13423       };
13424     }
13425   }
13426
13427   jresult = (void *)result;
13428   return jresult;
13429 }
13430
13431
13432 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_1(void * jarg1) {
13433   void * jresult ;
13434   Dali::Matrix3 *arg1 = 0 ;
13435   Dali::Matrix3 *result = 0 ;
13436
13437   arg1 = (Dali::Matrix3 *)jarg1;
13438   if (!arg1) {
13439     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13440     return 0;
13441   }
13442   {
13443     try {
13444       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix3 const &)*arg1);
13445     } catch (std::out_of_range& e) {
13446       {
13447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13448       };
13449     } catch (std::exception& e) {
13450       {
13451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13452       };
13453     } catch (Dali::DaliException e) {
13454       {
13455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13456       };
13457     } catch (...) {
13458       {
13459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13460       };
13461     }
13462   }
13463
13464   jresult = (void *)result;
13465   return jresult;
13466 }
13467
13468
13469 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_2(void * jarg1) {
13470   void * jresult ;
13471   Dali::Matrix *arg1 = 0 ;
13472   Dali::Matrix3 *result = 0 ;
13473
13474   arg1 = (Dali::Matrix *)jarg1;
13475   if (!arg1) {
13476     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13477     return 0;
13478   }
13479   {
13480     try {
13481       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix const &)*arg1);
13482     } catch (std::out_of_range& e) {
13483       {
13484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13485       };
13486     } catch (std::exception& e) {
13487       {
13488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13489       };
13490     } catch (Dali::DaliException e) {
13491       {
13492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13493       };
13494     } catch (...) {
13495       {
13496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13497       };
13498     }
13499   }
13500
13501   jresult = (void *)result;
13502   return jresult;
13503 }
13504
13505
13506 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) {
13507   void * jresult ;
13508   float arg1 ;
13509   float arg2 ;
13510   float arg3 ;
13511   float arg4 ;
13512   float arg5 ;
13513   float arg6 ;
13514   float arg7 ;
13515   float arg8 ;
13516   float arg9 ;
13517   Dali::Matrix3 *result = 0 ;
13518
13519   arg1 = (float)jarg1;
13520   arg2 = (float)jarg2;
13521   arg3 = (float)jarg3;
13522   arg4 = (float)jarg4;
13523   arg5 = (float)jarg5;
13524   arg6 = (float)jarg6;
13525   arg7 = (float)jarg7;
13526   arg8 = (float)jarg8;
13527   arg9 = (float)jarg9;
13528   {
13529     try {
13530       result = (Dali::Matrix3 *)new Dali::Matrix3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
13531     } catch (std::out_of_range& e) {
13532       {
13533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13534       };
13535     } catch (std::exception& e) {
13536       {
13537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13538       };
13539     } catch (Dali::DaliException e) {
13540       {
13541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13542       };
13543     } catch (...) {
13544       {
13545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13546       };
13547     }
13548   }
13549
13550   jresult = (void *)result;
13551   return jresult;
13552 }
13553
13554
13555 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_0(void * jarg1, void * jarg2) {
13556   void * jresult ;
13557   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13558   Dali::Matrix3 *arg2 = 0 ;
13559   Dali::Matrix3 *result = 0 ;
13560
13561   arg1 = (Dali::Matrix3 *)jarg1;
13562   arg2 = (Dali::Matrix3 *)jarg2;
13563   if (!arg2) {
13564     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13565     return 0;
13566   }
13567   {
13568     try {
13569       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix3 const &)*arg2);
13570     } catch (std::out_of_range& e) {
13571       {
13572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13573       };
13574     } catch (std::exception& e) {
13575       {
13576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13577       };
13578     } catch (Dali::DaliException e) {
13579       {
13580         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13581       };
13582     } catch (...) {
13583       {
13584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13585       };
13586     }
13587   }
13588
13589   jresult = (void *)result;
13590   return jresult;
13591 }
13592
13593
13594 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_1(void * jarg1, void * jarg2) {
13595   void * jresult ;
13596   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13597   Dali::Matrix *arg2 = 0 ;
13598   Dali::Matrix3 *result = 0 ;
13599
13600   arg1 = (Dali::Matrix3 *)jarg1;
13601   arg2 = (Dali::Matrix *)jarg2;
13602   if (!arg2) {
13603     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13604     return 0;
13605   }
13606   {
13607     try {
13608       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
13609     } catch (std::out_of_range& e) {
13610       {
13611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13612       };
13613     } catch (std::exception& e) {
13614       {
13615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13616       };
13617     } catch (Dali::DaliException e) {
13618       {
13619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13620       };
13621     } catch (...) {
13622       {
13623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13624       };
13625     }
13626   }
13627
13628   jresult = (void *)result;
13629   return jresult;
13630 }
13631
13632
13633 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_EqualTo(void * jarg1, void * jarg2) {
13634   unsigned int jresult ;
13635   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13636   Dali::Matrix3 *arg2 = 0 ;
13637   bool result;
13638
13639   arg1 = (Dali::Matrix3 *)jarg1;
13640   arg2 = (Dali::Matrix3 *)jarg2;
13641   if (!arg2) {
13642     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13643     return 0;
13644   }
13645   {
13646     try {
13647       result = (bool)((Dali::Matrix3 const *)arg1)->operator ==((Dali::Matrix3 const &)*arg2);
13648     } catch (std::out_of_range& e) {
13649       {
13650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13651       };
13652     } catch (std::exception& e) {
13653       {
13654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13655       };
13656     } catch (Dali::DaliException e) {
13657       {
13658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13659       };
13660     } catch (...) {
13661       {
13662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13663       };
13664     }
13665   }
13666
13667   jresult = result;
13668   return jresult;
13669 }
13670
13671
13672 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_NotEqualTo(void * jarg1, void * jarg2) {
13673   unsigned int jresult ;
13674   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13675   Dali::Matrix3 *arg2 = 0 ;
13676   bool result;
13677
13678   arg1 = (Dali::Matrix3 *)jarg1;
13679   arg2 = (Dali::Matrix3 *)jarg2;
13680   if (!arg2) {
13681     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13682     return 0;
13683   }
13684   {
13685     try {
13686       result = (bool)((Dali::Matrix3 const *)arg1)->operator !=((Dali::Matrix3 const &)*arg2);
13687     } catch (std::out_of_range& e) {
13688       {
13689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13690       };
13691     } catch (std::exception& e) {
13692       {
13693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13694       };
13695     } catch (Dali::DaliException e) {
13696       {
13697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13698       };
13699     } catch (...) {
13700       {
13701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13702       };
13703     }
13704   }
13705
13706   jresult = result;
13707   return jresult;
13708 }
13709
13710
13711 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix3(void * jarg1) {
13712   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13713
13714   arg1 = (Dali::Matrix3 *)jarg1;
13715   {
13716     try {
13717       delete arg1;
13718     } catch (std::out_of_range& e) {
13719       {
13720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13721       };
13722     } catch (std::exception& e) {
13723       {
13724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13725       };
13726     } catch (Dali::DaliException e) {
13727       {
13728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13729       };
13730     } catch (...) {
13731       {
13732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13733       };
13734     }
13735   }
13736
13737 }
13738
13739
13740 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_SetIdentity(void * jarg1) {
13741   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13742
13743   arg1 = (Dali::Matrix3 *)jarg1;
13744   {
13745     try {
13746       (arg1)->SetIdentity();
13747     } catch (std::out_of_range& e) {
13748       {
13749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13750       };
13751     } catch (std::exception& e) {
13752       {
13753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13754       };
13755     } catch (Dali::DaliException e) {
13756       {
13757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13758       };
13759     } catch (...) {
13760       {
13761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13762       };
13763     }
13764   }
13765
13766 }
13767
13768
13769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_AsFloat__SWIG_0(void * jarg1) {
13770   void * jresult ;
13771   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13772   float *result = 0 ;
13773
13774   arg1 = (Dali::Matrix3 *)jarg1;
13775   {
13776     try {
13777       result = (float *)((Dali::Matrix3 const *)arg1)->AsFloat();
13778     } catch (std::out_of_range& e) {
13779       {
13780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13781       };
13782     } catch (std::exception& e) {
13783       {
13784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13785       };
13786     } catch (Dali::DaliException e) {
13787       {
13788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13789       };
13790     } catch (...) {
13791       {
13792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13793       };
13794     }
13795   }
13796
13797   jresult = (void *)result;
13798   return jresult;
13799 }
13800
13801
13802 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Invert(void * jarg1) {
13803   unsigned int jresult ;
13804   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13805   bool result;
13806
13807   arg1 = (Dali::Matrix3 *)jarg1;
13808   {
13809     try {
13810       result = (bool)(arg1)->Invert();
13811     } catch (std::out_of_range& e) {
13812       {
13813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13814       };
13815     } catch (std::exception& e) {
13816       {
13817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13818       };
13819     } catch (Dali::DaliException e) {
13820       {
13821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13822       };
13823     } catch (...) {
13824       {
13825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13826       };
13827     }
13828   }
13829
13830   jresult = result;
13831   return jresult;
13832 }
13833
13834
13835 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Transpose(void * jarg1) {
13836   unsigned int jresult ;
13837   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13838   bool result;
13839
13840   arg1 = (Dali::Matrix3 *)jarg1;
13841   {
13842     try {
13843       result = (bool)(arg1)->Transpose();
13844     } catch (std::out_of_range& e) {
13845       {
13846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13847       };
13848     } catch (std::exception& e) {
13849       {
13850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13851       };
13852     } catch (Dali::DaliException e) {
13853       {
13854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13855       };
13856     } catch (...) {
13857       {
13858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13859       };
13860     }
13861   }
13862
13863   jresult = result;
13864   return jresult;
13865 }
13866
13867
13868 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Scale(void * jarg1, float jarg2) {
13869   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13870   float arg2 ;
13871
13872   arg1 = (Dali::Matrix3 *)jarg1;
13873   arg2 = (float)jarg2;
13874   {
13875     try {
13876       (arg1)->Scale(arg2);
13877     } catch (std::out_of_range& e) {
13878       {
13879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13880       };
13881     } catch (std::exception& e) {
13882       {
13883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13884       };
13885     } catch (Dali::DaliException e) {
13886       {
13887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13888       };
13889     } catch (...) {
13890       {
13891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13892       };
13893     }
13894   }
13895
13896 }
13897
13898
13899 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Matrix3_Magnitude(void * jarg1) {
13900   float jresult ;
13901   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13902   float result;
13903
13904   arg1 = (Dali::Matrix3 *)jarg1;
13905   {
13906     try {
13907       result = (float)((Dali::Matrix3 const *)arg1)->Magnitude();
13908     } catch (std::out_of_range& e) {
13909       {
13910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13911       };
13912     } catch (std::exception& e) {
13913       {
13914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13915       };
13916     } catch (Dali::DaliException e) {
13917       {
13918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13919       };
13920     } catch (...) {
13921       {
13922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13923       };
13924     }
13925   }
13926
13927   jresult = result;
13928   return jresult;
13929 }
13930
13931
13932 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_ScaledInverseTranspose(void * jarg1) {
13933   unsigned int jresult ;
13934   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13935   bool result;
13936
13937   arg1 = (Dali::Matrix3 *)jarg1;
13938   {
13939     try {
13940       result = (bool)(arg1)->ScaledInverseTranspose();
13941     } catch (std::out_of_range& e) {
13942       {
13943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13944       };
13945     } catch (std::exception& e) {
13946       {
13947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13948       };
13949     } catch (Dali::DaliException e) {
13950       {
13951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13952       };
13953     } catch (...) {
13954       {
13955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13956       };
13957     }
13958   }
13959
13960   jresult = result;
13961   return jresult;
13962 }
13963
13964
13965 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Multiply(void * jarg1, void * jarg2, void * jarg3) {
13966   Dali::Matrix3 *arg1 = 0 ;
13967   Dali::Matrix3 *arg2 = 0 ;
13968   Dali::Matrix3 *arg3 = 0 ;
13969
13970   arg1 = (Dali::Matrix3 *)jarg1;
13971   if (!arg1) {
13972     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
13973     return ;
13974   }
13975   arg2 = (Dali::Matrix3 *)jarg2;
13976   if (!arg2) {
13977     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13978     return ;
13979   }
13980   arg3 = (Dali::Matrix3 *)jarg3;
13981   if (!arg3) {
13982     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13983     return ;
13984   }
13985   {
13986     try {
13987       Dali::Matrix3::Multiply(*arg1,(Dali::Matrix3 const &)*arg2,(Dali::Matrix3 const &)*arg3);
13988     } catch (std::out_of_range& e) {
13989       {
13990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13991       };
13992     } catch (std::exception& e) {
13993       {
13994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13995       };
13996     } catch (Dali::DaliException e) {
13997       {
13998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13999       };
14000     } catch (...) {
14001       {
14002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14003       };
14004     }
14005   }
14006
14007 }
14008
14009
14010 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Range(float jarg1, float jarg2) {
14011   float jresult ;
14012   float arg1 ;
14013   float arg2 ;
14014   float result;
14015
14016   arg1 = (float)jarg1;
14017   arg2 = (float)jarg2;
14018   {
14019     try {
14020       result = (float)Dali::Random::Range(arg1,arg2);
14021     } catch (std::out_of_range& e) {
14022       {
14023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14024       };
14025     } catch (std::exception& e) {
14026       {
14027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14028       };
14029     } catch (Dali::DaliException e) {
14030       {
14031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14032       };
14033     } catch (...) {
14034       {
14035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14036       };
14037     }
14038   }
14039
14040   jresult = result;
14041   return jresult;
14042 }
14043
14044
14045 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Axis() {
14046   void * jresult ;
14047   Dali::Vector4 result;
14048
14049   {
14050     try {
14051       result = Dali::Random::Axis();
14052     } catch (std::out_of_range& e) {
14053       {
14054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14055       };
14056     } catch (std::exception& e) {
14057       {
14058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14059       };
14060     } catch (Dali::DaliException e) {
14061       {
14062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14063       };
14064     } catch (...) {
14065       {
14066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14067       };
14068     }
14069   }
14070
14071   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
14072   return jresult;
14073 }
14074
14075
14076 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_0() {
14077   void * jresult ;
14078   Dali::AngleAxis *result = 0 ;
14079
14080   {
14081     try {
14082       result = (Dali::AngleAxis *)new Dali::AngleAxis();
14083     } catch (std::out_of_range& e) {
14084       {
14085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14086       };
14087     } catch (std::exception& e) {
14088       {
14089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14090       };
14091     } catch (Dali::DaliException e) {
14092       {
14093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14094       };
14095     } catch (...) {
14096       {
14097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14098       };
14099     }
14100   }
14101
14102   jresult = (void *)result;
14103   return jresult;
14104 }
14105
14106
14107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_1(void * jarg1, void * jarg2) {
14108   void * jresult ;
14109   Dali::Radian arg1 ;
14110   Dali::Vector3 *arg2 = 0 ;
14111   Dali::Radian *argp1 ;
14112   Dali::AngleAxis *result = 0 ;
14113
14114   argp1 = (Dali::Radian *)jarg1;
14115   if (!argp1) {
14116     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
14117     return 0;
14118   }
14119   arg1 = *argp1;
14120   arg2 = (Dali::Vector3 *)jarg2;
14121   if (!arg2) {
14122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
14123     return 0;
14124   }
14125   {
14126     try {
14127       result = (Dali::AngleAxis *)new Dali::AngleAxis(arg1,(Dali::Vector3 const &)*arg2);
14128     } catch (std::out_of_range& e) {
14129       {
14130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14131       };
14132     } catch (std::exception& e) {
14133       {
14134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14135       };
14136     } catch (Dali::DaliException e) {
14137       {
14138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14139       };
14140     } catch (...) {
14141       {
14142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14143       };
14144     }
14145   }
14146
14147   jresult = (void *)result;
14148   return jresult;
14149 }
14150
14151
14152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_angle_set(void * jarg1, void * jarg2) {
14153   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14154   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
14155
14156   arg1 = (Dali::AngleAxis *)jarg1;
14157   arg2 = (Dali::Radian *)jarg2;
14158   if (arg1) (arg1)->angle = *arg2;
14159 }
14160
14161
14162 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_angle_get(void * jarg1) {
14163   void * jresult ;
14164   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14165   Dali::Radian *result = 0 ;
14166
14167   arg1 = (Dali::AngleAxis *)jarg1;
14168   result = (Dali::Radian *)& ((arg1)->angle);
14169   jresult = (void *)result;
14170   return jresult;
14171 }
14172
14173
14174 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_axis_set(void * jarg1, void * jarg2) {
14175   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14176   Dali::Vector3 *arg2 = (Dali::Vector3 *) 0 ;
14177
14178   arg1 = (Dali::AngleAxis *)jarg1;
14179   arg2 = (Dali::Vector3 *)jarg2;
14180   if (arg1) (arg1)->axis = *arg2;
14181 }
14182
14183
14184 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_axis_get(void * jarg1) {
14185   void * jresult ;
14186   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14187   Dali::Vector3 *result = 0 ;
14188
14189   arg1 = (Dali::AngleAxis *)jarg1;
14190   result = (Dali::Vector3 *)& ((arg1)->axis);
14191   jresult = (void *)result;
14192   return jresult;
14193 }
14194
14195
14196 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleAxis(void * jarg1) {
14197   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14198
14199   arg1 = (Dali::AngleAxis *)jarg1;
14200   {
14201     try {
14202       delete arg1;
14203     } catch (std::out_of_range& e) {
14204       {
14205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14206       };
14207     } catch (std::exception& e) {
14208       {
14209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14210       };
14211     } catch (Dali::DaliException e) {
14212       {
14213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14214       };
14215     } catch (...) {
14216       {
14217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14218       };
14219     }
14220   }
14221
14222 }
14223
14224
14225 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_9(void * jarg1, void * jarg2) {
14226   unsigned int jresult ;
14227   Dali::AngleAxis *arg1 = 0 ;
14228   Dali::AngleAxis *arg2 = 0 ;
14229   bool result;
14230
14231   arg1 = (Dali::AngleAxis *)jarg1;
14232   if (!arg1) {
14233     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
14234     return 0;
14235   }
14236   arg2 = (Dali::AngleAxis *)jarg2;
14237   if (!arg2) {
14238     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
14239     return 0;
14240   }
14241   {
14242     try {
14243       result = (bool)Dali::operator ==((Dali::AngleAxis const &)*arg1,(Dali::AngleAxis const &)*arg2);
14244     } catch (std::out_of_range& e) {
14245       {
14246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14247       };
14248     } catch (std::exception& e) {
14249       {
14250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14251       };
14252     } catch (Dali::DaliException e) {
14253       {
14254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14255       };
14256     } catch (...) {
14257       {
14258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14259       };
14260     }
14261   }
14262
14263   jresult = result;
14264   return jresult;
14265 }
14266
14267
14268 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NextPowerOfTwo(unsigned int jarg1) {
14269   unsigned int jresult ;
14270   unsigned int arg1 ;
14271   unsigned int result;
14272
14273   arg1 = (unsigned int)jarg1;
14274   {
14275     try {
14276       result = (unsigned int)Dali::NextPowerOfTwo(arg1);
14277     } catch (std::out_of_range& e) {
14278       {
14279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14280       };
14281     } catch (std::exception& e) {
14282       {
14283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14284       };
14285     } catch (Dali::DaliException e) {
14286       {
14287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14288       };
14289     } catch (...) {
14290       {
14291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14292       };
14293     }
14294   }
14295
14296   jresult = result;
14297   return jresult;
14298 }
14299
14300
14301 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsPowerOfTwo(unsigned int jarg1) {
14302   unsigned int jresult ;
14303   unsigned int arg1 ;
14304   bool result;
14305
14306   arg1 = (unsigned int)jarg1;
14307   {
14308     try {
14309       result = (bool)Dali::IsPowerOfTwo(arg1);
14310     } catch (std::out_of_range& e) {
14311       {
14312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14313       };
14314     } catch (std::exception& e) {
14315       {
14316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14317       };
14318     } catch (Dali::DaliException e) {
14319       {
14320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14321       };
14322     } catch (...) {
14323       {
14324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14325       };
14326     }
14327   }
14328
14329   jresult = result;
14330   return jresult;
14331 }
14332
14333
14334 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_GetRangedEpsilon(float jarg1, float jarg2) {
14335   float jresult ;
14336   float arg1 ;
14337   float arg2 ;
14338   float result;
14339
14340   arg1 = (float)jarg1;
14341   arg2 = (float)jarg2;
14342   {
14343     try {
14344       result = (float)Dali::GetRangedEpsilon(arg1,arg2);
14345     } catch (std::out_of_range& e) {
14346       {
14347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14348       };
14349     } catch (std::exception& e) {
14350       {
14351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14352       };
14353     } catch (Dali::DaliException e) {
14354       {
14355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14356       };
14357     } catch (...) {
14358       {
14359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14360       };
14361     }
14362   }
14363
14364   jresult = result;
14365   return jresult;
14366 }
14367
14368
14369 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualsZero(float jarg1) {
14370   unsigned int jresult ;
14371   float arg1 ;
14372   bool result;
14373
14374   arg1 = (float)jarg1;
14375   {
14376     try {
14377       result = (bool)Dali::EqualsZero(arg1);
14378     } catch (std::out_of_range& e) {
14379       {
14380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14381       };
14382     } catch (std::exception& e) {
14383       {
14384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14385       };
14386     } catch (Dali::DaliException e) {
14387       {
14388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14389       };
14390     } catch (...) {
14391       {
14392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14393       };
14394     }
14395   }
14396
14397   jresult = result;
14398   return jresult;
14399 }
14400
14401
14402 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_0(float jarg1, float jarg2) {
14403   unsigned int jresult ;
14404   float arg1 ;
14405   float arg2 ;
14406   bool result;
14407
14408   arg1 = (float)jarg1;
14409   arg2 = (float)jarg2;
14410   {
14411     try {
14412       result = (bool)Dali::Equals(arg1,arg2);
14413     } catch (std::out_of_range& e) {
14414       {
14415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14416       };
14417     } catch (std::exception& e) {
14418       {
14419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14420       };
14421     } catch (Dali::DaliException e) {
14422       {
14423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14424       };
14425     } catch (...) {
14426       {
14427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14428       };
14429     }
14430   }
14431
14432   jresult = result;
14433   return jresult;
14434 }
14435
14436
14437 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_1(float jarg1, float jarg2, float jarg3) {
14438   unsigned int jresult ;
14439   float arg1 ;
14440   float arg2 ;
14441   float arg3 ;
14442   bool result;
14443
14444   arg1 = (float)jarg1;
14445   arg2 = (float)jarg2;
14446   arg3 = (float)jarg3;
14447   {
14448     try {
14449       result = (bool)Dali::Equals(arg1,arg2,arg3);
14450     } catch (std::out_of_range& e) {
14451       {
14452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14453       };
14454     } catch (std::exception& e) {
14455       {
14456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14457       };
14458     } catch (Dali::DaliException e) {
14459       {
14460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14461       };
14462     } catch (...) {
14463       {
14464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14465       };
14466     }
14467   }
14468
14469   jresult = result;
14470   return jresult;
14471 }
14472
14473
14474 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Round(float jarg1, int jarg2) {
14475   float jresult ;
14476   float arg1 ;
14477   int arg2 ;
14478   float result;
14479
14480   arg1 = (float)jarg1;
14481   arg2 = (int)jarg2;
14482   {
14483     try {
14484       result = (float)Dali::Round(arg1,arg2);
14485     } catch (std::out_of_range& e) {
14486       {
14487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14488       };
14489     } catch (std::exception& e) {
14490       {
14491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14492       };
14493     } catch (Dali::DaliException e) {
14494       {
14495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14496       };
14497     } catch (...) {
14498       {
14499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14500       };
14501     }
14502   }
14503
14504   jresult = result;
14505   return jresult;
14506 }
14507
14508
14509 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_WrapInDomain(float jarg1, float jarg2, float jarg3) {
14510   float jresult ;
14511   float arg1 ;
14512   float arg2 ;
14513   float arg3 ;
14514   float result;
14515
14516   arg1 = (float)jarg1;
14517   arg2 = (float)jarg2;
14518   arg3 = (float)jarg3;
14519   {
14520     try {
14521       result = (float)Dali::WrapInDomain(arg1,arg2,arg3);
14522     } catch (std::out_of_range& e) {
14523       {
14524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14525       };
14526     } catch (std::exception& e) {
14527       {
14528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14529       };
14530     } catch (Dali::DaliException e) {
14531       {
14532         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14533       };
14534     } catch (...) {
14535       {
14536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14537       };
14538     }
14539   }
14540
14541   jresult = result;
14542   return jresult;
14543 }
14544
14545
14546 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ShortestDistanceInDomain(float jarg1, float jarg2, float jarg3, float jarg4) {
14547   float jresult ;
14548   float arg1 ;
14549   float arg2 ;
14550   float arg3 ;
14551   float arg4 ;
14552   float result;
14553
14554   arg1 = (float)jarg1;
14555   arg2 = (float)jarg2;
14556   arg3 = (float)jarg3;
14557   arg4 = (float)jarg4;
14558   {
14559     try {
14560       result = (float)Dali::ShortestDistanceInDomain(arg1,arg2,arg3,arg4);
14561     } catch (std::out_of_range& e) {
14562       {
14563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14564       };
14565     } catch (std::exception& e) {
14566       {
14567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14568       };
14569     } catch (Dali::DaliException e) {
14570       {
14571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14572       };
14573     } catch (...) {
14574       {
14575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14576       };
14577     }
14578   }
14579
14580   jresult = result;
14581   return jresult;
14582 }
14583
14584
14585 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_INDEX_get() {
14586   int jresult ;
14587   int result;
14588
14589   result = (int)(int)Dali::Property::INVALID_INDEX;
14590   jresult = result;
14591   return jresult;
14592 }
14593
14594
14595 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_KEY_get() {
14596   int jresult ;
14597   int result;
14598
14599   result = (int)(int)Dali::Property::INVALID_KEY;
14600   jresult = result;
14601   return jresult;
14602 }
14603
14604
14605 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_COMPONENT_INDEX_get() {
14606   int jresult ;
14607   int result;
14608
14609   result = (int)(int)Dali::Property::INVALID_COMPONENT_INDEX;
14610   jresult = result;
14611   return jresult;
14612 }
14613
14614
14615 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_0(void * jarg1, int jarg2) {
14616   void * jresult ;
14617   Dali::Handle *arg1 = 0 ;
14618   Dali::Property::Index arg2 ;
14619   Dali::Property *result = 0 ;
14620
14621   arg1 = (Dali::Handle *)jarg1;
14622   if (!arg1) {
14623     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14624     return 0;
14625   }
14626   arg2 = (Dali::Property::Index)jarg2;
14627   {
14628     try {
14629       result = (Dali::Property *)new Dali::Property(*arg1,arg2);
14630     } catch (std::out_of_range& e) {
14631       {
14632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14633       };
14634     } catch (std::exception& e) {
14635       {
14636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14637       };
14638     } catch (Dali::DaliException e) {
14639       {
14640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14641       };
14642     } catch (...) {
14643       {
14644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14645       };
14646     }
14647   }
14648
14649   jresult = (void *)result;
14650   return jresult;
14651 }
14652
14653
14654 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_1(void * jarg1, int jarg2, int jarg3) {
14655   void * jresult ;
14656   Dali::Handle *arg1 = 0 ;
14657   Dali::Property::Index arg2 ;
14658   int arg3 ;
14659   Dali::Property *result = 0 ;
14660
14661   arg1 = (Dali::Handle *)jarg1;
14662   if (!arg1) {
14663     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14664     return 0;
14665   }
14666   arg2 = (Dali::Property::Index)jarg2;
14667   arg3 = (int)jarg3;
14668   {
14669     try {
14670       result = (Dali::Property *)new Dali::Property(*arg1,arg2,arg3);
14671     } catch (std::out_of_range& e) {
14672       {
14673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14674       };
14675     } catch (std::exception& e) {
14676       {
14677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14678       };
14679     } catch (Dali::DaliException e) {
14680       {
14681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14682       };
14683     } catch (...) {
14684       {
14685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14686       };
14687     }
14688   }
14689
14690   jresult = (void *)result;
14691   return jresult;
14692 }
14693
14694
14695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_2(void * jarg1, char * jarg2) {
14696   void * jresult ;
14697   Dali::Handle *arg1 = 0 ;
14698   std::string *arg2 = 0 ;
14699   Dali::Property *result = 0 ;
14700
14701   arg1 = (Dali::Handle *)jarg1;
14702   if (!arg1) {
14703     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14704     return 0;
14705   }
14706   if (!jarg2) {
14707     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14708     return 0;
14709   }
14710   std::string arg2_str(jarg2);
14711   arg2 = &arg2_str;
14712   {
14713     try {
14714       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2);
14715     } catch (std::out_of_range& e) {
14716       {
14717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14718       };
14719     } catch (std::exception& e) {
14720       {
14721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14722       };
14723     } catch (Dali::DaliException e) {
14724       {
14725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14726       };
14727     } catch (...) {
14728       {
14729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14730       };
14731     }
14732   }
14733
14734   jresult = (void *)result;
14735
14736   //argout typemap for const std::string&
14737
14738   return jresult;
14739 }
14740
14741
14742 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_3(void * jarg1, char * jarg2, int jarg3) {
14743   void * jresult ;
14744   Dali::Handle *arg1 = 0 ;
14745   std::string *arg2 = 0 ;
14746   int arg3 ;
14747   Dali::Property *result = 0 ;
14748
14749   arg1 = (Dali::Handle *)jarg1;
14750   if (!arg1) {
14751     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14752     return 0;
14753   }
14754   if (!jarg2) {
14755     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14756     return 0;
14757   }
14758   std::string arg2_str(jarg2);
14759   arg2 = &arg2_str;
14760   arg3 = (int)jarg3;
14761   {
14762     try {
14763       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2,arg3);
14764     } catch (std::out_of_range& e) {
14765       {
14766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14767       };
14768     } catch (std::exception& e) {
14769       {
14770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14771       };
14772     } catch (Dali::DaliException e) {
14773       {
14774         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14775       };
14776     } catch (...) {
14777       {
14778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14779       };
14780     }
14781   }
14782
14783   jresult = (void *)result;
14784
14785   //argout typemap for const std::string&
14786
14787   return jresult;
14788 }
14789
14790
14791 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property(void * jarg1) {
14792   Dali::Property *arg1 = (Dali::Property *) 0 ;
14793
14794   arg1 = (Dali::Property *)jarg1;
14795   {
14796     try {
14797       delete arg1;
14798     } catch (std::out_of_range& e) {
14799       {
14800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14801       };
14802     } catch (std::exception& e) {
14803       {
14804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14805       };
14806     } catch (Dali::DaliException e) {
14807       {
14808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14809       };
14810     } catch (...) {
14811       {
14812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14813       };
14814     }
14815   }
14816
14817 }
14818
14819
14820 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property__object_set(void * jarg1, void * jarg2) {
14821   Dali::Property *arg1 = (Dali::Property *) 0 ;
14822   Dali::Handle *arg2 = 0 ;
14823
14824   arg1 = (Dali::Property *)jarg1;
14825   arg2 = (Dali::Handle *)jarg2;
14826   if (!arg2) {
14827     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14828     return ;
14829   }
14830   if (arg1) (arg1)->object = *arg2;
14831 }
14832
14833
14834 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property__object_get(void * jarg1) {
14835   void * jresult ;
14836   Dali::Property *arg1 = (Dali::Property *) 0 ;
14837   Dali::Handle *result = 0 ;
14838
14839   arg1 = (Dali::Property *)jarg1;
14840   result = (Dali::Handle *) &(Dali::Handle &) ((arg1)->object);
14841   jresult = (void *)result;
14842   return jresult;
14843 }
14844
14845
14846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_propertyIndex_set(void * jarg1, int jarg2) {
14847   Dali::Property *arg1 = (Dali::Property *) 0 ;
14848   Dali::Property::Index arg2 ;
14849
14850   arg1 = (Dali::Property *)jarg1;
14851   arg2 = (Dali::Property::Index)jarg2;
14852   if (arg1) (arg1)->propertyIndex = arg2;
14853 }
14854
14855
14856 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_propertyIndex_get(void * jarg1) {
14857   int jresult ;
14858   Dali::Property *arg1 = (Dali::Property *) 0 ;
14859   Dali::Property::Index result;
14860
14861   arg1 = (Dali::Property *)jarg1;
14862   result = (Dali::Property::Index) ((arg1)->propertyIndex);
14863   jresult = result;
14864   return jresult;
14865 }
14866
14867
14868 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_componentIndex_set(void * jarg1, int jarg2) {
14869   Dali::Property *arg1 = (Dali::Property *) 0 ;
14870   int arg2 ;
14871
14872   arg1 = (Dali::Property *)jarg1;
14873   arg2 = (int)jarg2;
14874   if (arg1) (arg1)->componentIndex = arg2;
14875 }
14876
14877
14878 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_componentIndex_get(void * jarg1) {
14879   int jresult ;
14880   Dali::Property *arg1 = (Dali::Property *) 0 ;
14881   int result;
14882
14883   arg1 = (Dali::Property *)jarg1;
14884   result = (int) ((arg1)->componentIndex);
14885   jresult = result;
14886   return jresult;
14887 }
14888
14889
14890 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_0() {
14891   void * jresult ;
14892   Dali::Property::Array *result = 0 ;
14893
14894   {
14895     try {
14896       result = (Dali::Property::Array *)new Dali::Property::Array();
14897     } catch (std::out_of_range& e) {
14898       {
14899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14900       };
14901     } catch (std::exception& e) {
14902       {
14903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14904       };
14905     } catch (Dali::DaliException e) {
14906       {
14907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14908       };
14909     } catch (...) {
14910       {
14911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14912       };
14913     }
14914   }
14915
14916   jresult = (void *)result;
14917   return jresult;
14918 }
14919
14920
14921 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_1(void * jarg1) {
14922   void * jresult ;
14923   Dali::Property::Array *arg1 = 0 ;
14924   Dali::Property::Array *result = 0 ;
14925
14926   arg1 = (Dali::Property::Array *)jarg1;
14927   if (!arg1) {
14928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
14929     return 0;
14930   }
14931   {
14932     try {
14933       result = (Dali::Property::Array *)new Dali::Property::Array((Dali::Property::Array const &)*arg1);
14934     } catch (std::out_of_range& e) {
14935       {
14936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14937       };
14938     } catch (std::exception& e) {
14939       {
14940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14941       };
14942     } catch (Dali::DaliException e) {
14943       {
14944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14945       };
14946     } catch (...) {
14947       {
14948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14949       };
14950     }
14951   }
14952
14953   jresult = (void *)result;
14954   return jresult;
14955 }
14956
14957
14958 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Array(void * jarg1) {
14959   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
14960
14961   arg1 = (Dali::Property::Array *)jarg1;
14962   {
14963     try {
14964       delete arg1;
14965     } catch (std::out_of_range& e) {
14966       {
14967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14968       };
14969     } catch (std::exception& e) {
14970       {
14971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14972       };
14973     } catch (Dali::DaliException e) {
14974       {
14975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14976       };
14977     } catch (...) {
14978       {
14979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14980       };
14981     }
14982   }
14983
14984 }
14985
14986
14987 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Size(void * jarg1) {
14988   unsigned long jresult ;
14989   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
14990   Dali::Property::Array::SizeType result;
14991
14992   arg1 = (Dali::Property::Array *)jarg1;
14993   {
14994     try {
14995       result = ((Dali::Property::Array const *)arg1)->Size();
14996     } catch (std::out_of_range& e) {
14997       {
14998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14999       };
15000     } catch (std::exception& e) {
15001       {
15002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15003       };
15004     } catch (Dali::DaliException e) {
15005       {
15006         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15007       };
15008     } catch (...) {
15009       {
15010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15011       };
15012     }
15013   }
15014
15015   jresult = (unsigned long)result;
15016   return jresult;
15017 }
15018
15019
15020 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Count(void * jarg1) {
15021   unsigned long jresult ;
15022   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15023   Dali::Property::Array::SizeType result;
15024
15025   arg1 = (Dali::Property::Array *)jarg1;
15026   {
15027     try {
15028       result = ((Dali::Property::Array const *)arg1)->Count();
15029     } catch (std::out_of_range& e) {
15030       {
15031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15032       };
15033     } catch (std::exception& e) {
15034       {
15035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15036       };
15037     } catch (Dali::DaliException e) {
15038       {
15039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15040       };
15041     } catch (...) {
15042       {
15043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15044       };
15045     }
15046   }
15047
15048   jresult = (unsigned long)result;
15049   return jresult;
15050 }
15051
15052
15053 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Array_Empty(void * jarg1) {
15054   unsigned int jresult ;
15055   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15056   bool result;
15057
15058   arg1 = (Dali::Property::Array *)jarg1;
15059   {
15060     try {
15061       result = (bool)((Dali::Property::Array const *)arg1)->Empty();
15062     } catch (std::out_of_range& e) {
15063       {
15064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15065       };
15066     } catch (std::exception& e) {
15067       {
15068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15069       };
15070     } catch (Dali::DaliException e) {
15071       {
15072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15073       };
15074     } catch (...) {
15075       {
15076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15077       };
15078     }
15079   }
15080
15081   jresult = result;
15082   return jresult;
15083 }
15084
15085
15086 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Clear(void * jarg1) {
15087   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15088
15089   arg1 = (Dali::Property::Array *)jarg1;
15090   {
15091     try {
15092       (arg1)->Clear();
15093     } catch (std::out_of_range& e) {
15094       {
15095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15096       };
15097     } catch (std::exception& e) {
15098       {
15099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15100       };
15101     } catch (Dali::DaliException e) {
15102       {
15103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15104       };
15105     } catch (...) {
15106       {
15107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15108       };
15109     }
15110   }
15111
15112 }
15113
15114
15115 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Reserve(void * jarg1, unsigned long jarg2) {
15116   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15117   Dali::Property::Array::SizeType arg2 ;
15118
15119   arg1 = (Dali::Property::Array *)jarg1;
15120   arg2 = (Dali::Property::Array::SizeType)jarg2;
15121   {
15122     try {
15123       (arg1)->Reserve(arg2);
15124     } catch (std::out_of_range& e) {
15125       {
15126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15127       };
15128     } catch (std::exception& e) {
15129       {
15130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15131       };
15132     } catch (Dali::DaliException e) {
15133       {
15134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15135       };
15136     } catch (...) {
15137       {
15138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15139       };
15140     }
15141   }
15142
15143 }
15144
15145
15146 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Resize(void * jarg1, unsigned long jarg2) {
15147   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15148   Dali::Property::Array::SizeType arg2 ;
15149
15150   arg1 = (Dali::Property::Array *)jarg1;
15151   arg2 = (Dali::Property::Array::SizeType)jarg2;
15152   {
15153     try {
15154       (arg1)->Resize(arg2);
15155     } catch (std::out_of_range& e) {
15156       {
15157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15158       };
15159     } catch (std::exception& e) {
15160       {
15161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15162       };
15163     } catch (Dali::DaliException e) {
15164       {
15165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15166       };
15167     } catch (...) {
15168       {
15169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15170       };
15171     }
15172   }
15173
15174 }
15175
15176
15177 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Capacity(void * jarg1) {
15178   unsigned long jresult ;
15179   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15180   Dali::Property::Array::SizeType result;
15181
15182   arg1 = (Dali::Property::Array *)jarg1;
15183   {
15184     try {
15185       result = (arg1)->Capacity();
15186     } catch (std::out_of_range& e) {
15187       {
15188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15189       };
15190     } catch (std::exception& e) {
15191       {
15192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15193       };
15194     } catch (Dali::DaliException e) {
15195       {
15196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15197       };
15198     } catch (...) {
15199       {
15200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15201       };
15202     }
15203   }
15204
15205   jresult = (unsigned long)result;
15206   return jresult;
15207 }
15208
15209
15210 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_PushBack(void * jarg1, void * jarg2) {
15211   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15212   Dali::Property::Value *arg2 = 0 ;
15213
15214   arg1 = (Dali::Property::Array *)jarg1;
15215   arg2 = (Dali::Property::Value *)jarg2;
15216   if (!arg2) {
15217     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15218     return ;
15219   }
15220   {
15221     try {
15222       (arg1)->PushBack((Dali::Property::Value const &)*arg2);
15223     } catch (std::out_of_range& e) {
15224       {
15225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15226       };
15227     } catch (std::exception& e) {
15228       {
15229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15230       };
15231     } catch (Dali::DaliException e) {
15232       {
15233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15234       };
15235     } catch (...) {
15236       {
15237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15238       };
15239     }
15240   }
15241
15242 }
15243
15244
15245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Add(void * jarg1, void * jarg2) {
15246   void * jresult ;
15247   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15248   Dali::Property::Value *arg2 = 0 ;
15249   Dali::Property::Array *result = 0 ;
15250
15251   arg1 = (Dali::Property::Array *)jarg1;
15252   arg2 = (Dali::Property::Value *)jarg2;
15253   if (!arg2) {
15254     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15255     return 0;
15256   }
15257   {
15258     try {
15259       result = (Dali::Property::Array *) &(arg1)->Add((Dali::Property::Value const &)*arg2);
15260     } catch (std::out_of_range& e) {
15261       {
15262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15263       };
15264     } catch (std::exception& e) {
15265       {
15266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15267       };
15268     } catch (Dali::DaliException e) {
15269       {
15270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15271       };
15272     } catch (...) {
15273       {
15274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15275       };
15276     }
15277   }
15278
15279   jresult = (void *)result;
15280   return jresult;
15281 }
15282
15283
15284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_GetElementAt__SWIG_0(void * jarg1, unsigned long jarg2) {
15285   void * jresult ;
15286   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15287   Dali::Property::Array::SizeType arg2 ;
15288   Dali::Property::Value *result = 0 ;
15289
15290   arg1 = (Dali::Property::Array *)jarg1;
15291   arg2 = (Dali::Property::Array::SizeType)jarg2;
15292   {
15293     try {
15294       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->GetElementAt(arg2);
15295     } catch (std::out_of_range& e) {
15296       {
15297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15298       };
15299     } catch (std::exception& e) {
15300       {
15301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15302       };
15303     } catch (Dali::DaliException e) {
15304       {
15305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15306       };
15307     } catch (...) {
15308       {
15309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15310       };
15311     }
15312   }
15313
15314   jresult = (void *)result;
15315   return jresult;
15316 }
15317
15318
15319 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
15320   void * jresult ;
15321   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15322   Dali::Property::Array::SizeType arg2 ;
15323   Dali::Property::Value *result = 0 ;
15324
15325   arg1 = (Dali::Property::Array *)jarg1;
15326   arg2 = (Dali::Property::Array::SizeType)jarg2;
15327   {
15328     try {
15329       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->operator [](arg2);
15330     } catch (std::out_of_range& e) {
15331       {
15332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15333       };
15334     } catch (std::exception& e) {
15335       {
15336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15337       };
15338     } catch (Dali::DaliException e) {
15339       {
15340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15341       };
15342     } catch (...) {
15343       {
15344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15345       };
15346     }
15347   }
15348
15349   jresult = (void *)result;
15350   return jresult;
15351 }
15352
15353
15354 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Assign(void * jarg1, void * jarg2) {
15355   void * jresult ;
15356   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15357   Dali::Property::Array *arg2 = 0 ;
15358   Dali::Property::Array *result = 0 ;
15359
15360   arg1 = (Dali::Property::Array *)jarg1;
15361   arg2 = (Dali::Property::Array *)jarg2;
15362   if (!arg2) {
15363     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
15364     return 0;
15365   }
15366   {
15367     try {
15368       result = (Dali::Property::Array *) &(arg1)->operator =((Dali::Property::Array const &)*arg2);
15369     } catch (std::out_of_range& e) {
15370       {
15371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15372       };
15373     } catch (std::exception& e) {
15374       {
15375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15376       };
15377     } catch (Dali::DaliException e) {
15378       {
15379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15380       };
15381     } catch (...) {
15382       {
15383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15384       };
15385     }
15386   }
15387
15388   jresult = (void *)result;
15389   return jresult;
15390 }
15391
15392
15393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_type_set(void * jarg1, int jarg2) {
15394   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15395   enum Dali::Property::Key::Type arg2 ;
15396
15397   arg1 = (Dali::Property::Key *)jarg1;
15398   arg2 = (enum Dali::Property::Key::Type)jarg2;
15399   if (arg1) (arg1)->type = arg2;
15400 }
15401
15402
15403 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_type_get(void * jarg1) {
15404   int jresult ;
15405   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15406   enum Dali::Property::Key::Type result;
15407
15408   arg1 = (Dali::Property::Key *)jarg1;
15409   result = (enum Dali::Property::Key::Type) ((arg1)->type);
15410   jresult = (int)result;
15411   return jresult;
15412 }
15413
15414
15415 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_set(void * jarg1, int jarg2) {
15416   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15417   Dali::Property::Index arg2 ;
15418
15419   arg1 = (Dali::Property::Key *)jarg1;
15420   arg2 = (Dali::Property::Index)jarg2;
15421   if (arg1) (arg1)->indexKey = arg2;
15422 }
15423
15424
15425 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_get(void * jarg1) {
15426   int jresult ;
15427   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15428   Dali::Property::Index result;
15429
15430   arg1 = (Dali::Property::Key *)jarg1;
15431   result = (Dali::Property::Index) ((arg1)->indexKey);
15432   jresult = result;
15433   return jresult;
15434 }
15435
15436
15437 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_set(void * jarg1, char * jarg2) {
15438   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15439   std::string *arg2 = 0 ;
15440
15441   arg1 = (Dali::Property::Key *)jarg1;
15442   if (!jarg2) {
15443     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15444     return ;
15445   }
15446   std::string arg2_str(jarg2);
15447   arg2 = &arg2_str;
15448   if (arg1) (arg1)->stringKey = *arg2;
15449
15450   //argout typemap for const std::string&
15451
15452 }
15453
15454
15455 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_get(void * jarg1) {
15456   char * jresult ;
15457   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15458   std::string *result = 0 ;
15459
15460   arg1 = (Dali::Property::Key *)jarg1;
15461   result = (std::string *) & ((arg1)->stringKey);
15462   jresult = SWIG_csharp_string_callback(result->c_str());
15463   return jresult;
15464 }
15465
15466
15467 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_0(char * jarg1) {
15468   void * jresult ;
15469   std::string *arg1 = 0 ;
15470   Dali::Property::Key *result = 0 ;
15471
15472   if (!jarg1) {
15473     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15474     return 0;
15475   }
15476   std::string arg1_str(jarg1);
15477   arg1 = &arg1_str;
15478   {
15479     try {
15480       result = (Dali::Property::Key *)new Dali::Property::Key((std::string const &)*arg1);
15481     } catch (std::out_of_range& e) {
15482       {
15483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15484       };
15485     } catch (std::exception& e) {
15486       {
15487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15488       };
15489     } catch (Dali::DaliException e) {
15490       {
15491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15492       };
15493     } catch (...) {
15494       {
15495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15496       };
15497     }
15498   }
15499
15500   jresult = (void *)result;
15501
15502   //argout typemap for const std::string&
15503
15504   return jresult;
15505 }
15506
15507
15508 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_1(int jarg1) {
15509   void * jresult ;
15510   Dali::Property::Index arg1 ;
15511   Dali::Property::Key *result = 0 ;
15512
15513   arg1 = (Dali::Property::Index)jarg1;
15514   {
15515     try {
15516       result = (Dali::Property::Key *)new Dali::Property::Key(arg1);
15517     } catch (std::out_of_range& e) {
15518       {
15519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15520       };
15521     } catch (std::exception& e) {
15522       {
15523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15524       };
15525     } catch (Dali::DaliException e) {
15526       {
15527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15528       };
15529     } catch (...) {
15530       {
15531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15532       };
15533     }
15534   }
15535
15536   jresult = (void *)result;
15537   return jresult;
15538 }
15539
15540
15541 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_0(void * jarg1, char * jarg2) {
15542   unsigned int jresult ;
15543   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15544   std::string *arg2 = 0 ;
15545   bool result;
15546
15547   arg1 = (Dali::Property::Key *)jarg1;
15548   if (!jarg2) {
15549     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15550     return 0;
15551   }
15552   std::string arg2_str(jarg2);
15553   arg2 = &arg2_str;
15554   {
15555     try {
15556       result = (bool)(arg1)->operator ==((std::string const &)*arg2);
15557     } catch (std::out_of_range& e) {
15558       {
15559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15560       };
15561     } catch (std::exception& e) {
15562       {
15563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15564       };
15565     } catch (Dali::DaliException e) {
15566       {
15567         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15568       };
15569     } catch (...) {
15570       {
15571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15572       };
15573     }
15574   }
15575
15576   jresult = result;
15577
15578   //argout typemap for const std::string&
15579
15580   return jresult;
15581 }
15582
15583
15584 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_1(void * jarg1, int jarg2) {
15585   unsigned int jresult ;
15586   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15587   Dali::Property::Index arg2 ;
15588   bool result;
15589
15590   arg1 = (Dali::Property::Key *)jarg1;
15591   arg2 = (Dali::Property::Index)jarg2;
15592   {
15593     try {
15594       result = (bool)(arg1)->operator ==(arg2);
15595     } catch (std::out_of_range& e) {
15596       {
15597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15598       };
15599     } catch (std::exception& e) {
15600       {
15601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15602       };
15603     } catch (Dali::DaliException e) {
15604       {
15605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15606       };
15607     } catch (...) {
15608       {
15609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15610       };
15611     }
15612   }
15613
15614   jresult = result;
15615   return jresult;
15616 }
15617
15618
15619 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_2(void * jarg1, void * jarg2) {
15620   unsigned int jresult ;
15621   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15622   Dali::Property::Key *arg2 = 0 ;
15623   bool result;
15624
15625   arg1 = (Dali::Property::Key *)jarg1;
15626   arg2 = (Dali::Property::Key *)jarg2;
15627   if (!arg2) {
15628     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
15629     return 0;
15630   }
15631   {
15632     try {
15633       result = (bool)(arg1)->operator ==((Dali::Property::Key const &)*arg2);
15634     } catch (std::out_of_range& e) {
15635       {
15636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15637       };
15638     } catch (std::exception& e) {
15639       {
15640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15641       };
15642     } catch (Dali::DaliException e) {
15643       {
15644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15645       };
15646     } catch (...) {
15647       {
15648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15649       };
15650     }
15651   }
15652
15653   jresult = result;
15654   return jresult;
15655 }
15656
15657
15658 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_0(void * jarg1, char * jarg2) {
15659   unsigned int jresult ;
15660   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15661   std::string *arg2 = 0 ;
15662   bool result;
15663
15664   arg1 = (Dali::Property::Key *)jarg1;
15665   if (!jarg2) {
15666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15667     return 0;
15668   }
15669   std::string arg2_str(jarg2);
15670   arg2 = &arg2_str;
15671   {
15672     try {
15673       result = (bool)(arg1)->operator !=((std::string const &)*arg2);
15674     } catch (std::out_of_range& e) {
15675       {
15676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15677       };
15678     } catch (std::exception& e) {
15679       {
15680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15681       };
15682     } catch (Dali::DaliException e) {
15683       {
15684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15685       };
15686     } catch (...) {
15687       {
15688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15689       };
15690     }
15691   }
15692
15693   jresult = result;
15694
15695   //argout typemap for const std::string&
15696
15697   return jresult;
15698 }
15699
15700
15701 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_1(void * jarg1, int jarg2) {
15702   unsigned int jresult ;
15703   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15704   Dali::Property::Index arg2 ;
15705   bool result;
15706
15707   arg1 = (Dali::Property::Key *)jarg1;
15708   arg2 = (Dali::Property::Index)jarg2;
15709   {
15710     try {
15711       result = (bool)(arg1)->operator !=(arg2);
15712     } catch (std::out_of_range& e) {
15713       {
15714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15715       };
15716     } catch (std::exception& e) {
15717       {
15718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15719       };
15720     } catch (Dali::DaliException e) {
15721       {
15722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15723       };
15724     } catch (...) {
15725       {
15726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15727       };
15728     }
15729   }
15730
15731   jresult = result;
15732   return jresult;
15733 }
15734
15735
15736 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_2(void * jarg1, void * jarg2) {
15737   unsigned int jresult ;
15738   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15739   Dali::Property::Key *arg2 = 0 ;
15740   bool result;
15741
15742   arg1 = (Dali::Property::Key *)jarg1;
15743   arg2 = (Dali::Property::Key *)jarg2;
15744   if (!arg2) {
15745     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
15746     return 0;
15747   }
15748   {
15749     try {
15750       result = (bool)(arg1)->operator !=((Dali::Property::Key const &)*arg2);
15751     } catch (std::out_of_range& e) {
15752       {
15753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15754       };
15755     } catch (std::exception& e) {
15756       {
15757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15758       };
15759     } catch (Dali::DaliException e) {
15760       {
15761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15762       };
15763     } catch (...) {
15764       {
15765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15766       };
15767     }
15768   }
15769
15770   jresult = result;
15771   return jresult;
15772 }
15773
15774
15775 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Key(void * jarg1) {
15776   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15777
15778   arg1 = (Dali::Property::Key *)jarg1;
15779   {
15780     try {
15781       delete arg1;
15782     } catch (std::out_of_range& e) {
15783       {
15784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15785       };
15786     } catch (std::exception& e) {
15787       {
15788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15789       };
15790     } catch (Dali::DaliException e) {
15791       {
15792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15793       };
15794     } catch (...) {
15795       {
15796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15797       };
15798     }
15799   }
15800
15801 }
15802
15803
15804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_0() {
15805   void * jresult ;
15806   Dali::Property::Map *result = 0 ;
15807
15808   {
15809     try {
15810       result = (Dali::Property::Map *)new Dali::Property::Map();
15811     } catch (std::out_of_range& e) {
15812       {
15813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15814       };
15815     } catch (std::exception& e) {
15816       {
15817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15818       };
15819     } catch (Dali::DaliException e) {
15820       {
15821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15822       };
15823     } catch (...) {
15824       {
15825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15826       };
15827     }
15828   }
15829
15830   jresult = (void *)result;
15831   return jresult;
15832 }
15833
15834
15835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_1(void * jarg1) {
15836   void * jresult ;
15837   Dali::Property::Map *arg1 = 0 ;
15838   Dali::Property::Map *result = 0 ;
15839
15840   arg1 = (Dali::Property::Map *)jarg1;
15841   if (!arg1) {
15842     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
15843     return 0;
15844   }
15845   {
15846     try {
15847       result = (Dali::Property::Map *)new Dali::Property::Map((Dali::Property::Map const &)*arg1);
15848     } catch (std::out_of_range& e) {
15849       {
15850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15851       };
15852     } catch (std::exception& e) {
15853       {
15854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15855       };
15856     } catch (Dali::DaliException e) {
15857       {
15858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15859       };
15860     } catch (...) {
15861       {
15862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15863       };
15864     }
15865   }
15866
15867   jresult = (void *)result;
15868   return jresult;
15869 }
15870
15871
15872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Map(void * jarg1) {
15873   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15874
15875   arg1 = (Dali::Property::Map *)jarg1;
15876   {
15877     try {
15878       delete arg1;
15879     } catch (std::out_of_range& e) {
15880       {
15881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15882       };
15883     } catch (std::exception& e) {
15884       {
15885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15886       };
15887     } catch (Dali::DaliException e) {
15888       {
15889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15890       };
15891     } catch (...) {
15892       {
15893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15894       };
15895     }
15896   }
15897
15898 }
15899
15900
15901 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Map_Count(void * jarg1) {
15902   unsigned long jresult ;
15903   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15904   Dali::Property::Map::SizeType result;
15905
15906   arg1 = (Dali::Property::Map *)jarg1;
15907   {
15908     try {
15909       result = ((Dali::Property::Map const *)arg1)->Count();
15910     } catch (std::out_of_range& e) {
15911       {
15912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15913       };
15914     } catch (std::exception& e) {
15915       {
15916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15917       };
15918     } catch (Dali::DaliException e) {
15919       {
15920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15921       };
15922     } catch (...) {
15923       {
15924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15925       };
15926     }
15927   }
15928
15929   jresult = (unsigned long)result;
15930   return jresult;
15931 }
15932
15933
15934 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Map_Empty(void * jarg1) {
15935   unsigned int jresult ;
15936   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15937   bool result;
15938
15939   arg1 = (Dali::Property::Map *)jarg1;
15940   {
15941     try {
15942       result = (bool)((Dali::Property::Map const *)arg1)->Empty();
15943     } catch (std::out_of_range& e) {
15944       {
15945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15946       };
15947     } catch (std::exception& e) {
15948       {
15949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15950       };
15951     } catch (Dali::DaliException e) {
15952       {
15953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15954       };
15955     } catch (...) {
15956       {
15957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15958       };
15959     }
15960   }
15961
15962   jresult = result;
15963   return jresult;
15964 }
15965
15966
15967 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
15968   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15969   char *arg2 = (char *) 0 ;
15970   Dali::Property::Value *arg3 = 0 ;
15971
15972   arg1 = (Dali::Property::Map *)jarg1;
15973   arg2 = (char *)jarg2;
15974   arg3 = (Dali::Property::Value *)jarg3;
15975   if (!arg3) {
15976     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15977     return ;
15978   }
15979   {
15980     try {
15981       (arg1)->Insert((char const *)arg2,(Dali::Property::Value const &)*arg3);
15982     } catch (std::out_of_range& e) {
15983       {
15984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15985       };
15986     } catch (std::exception& e) {
15987       {
15988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15989       };
15990     } catch (Dali::DaliException e) {
15991       {
15992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15993       };
15994     } catch (...) {
15995       {
15996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15997       };
15998     }
15999   }
16000
16001 }
16002
16003
16004 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
16005   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16006   Dali::Property::Index arg2 ;
16007   Dali::Property::Value *arg3 = 0 ;
16008
16009   arg1 = (Dali::Property::Map *)jarg1;
16010   arg2 = (Dali::Property::Index)jarg2;
16011   arg3 = (Dali::Property::Value *)jarg3;
16012   if (!arg3) {
16013     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
16014     return ;
16015   }
16016   {
16017     try {
16018       (arg1)->Insert(arg2,(Dali::Property::Value const &)*arg3);
16019     } catch (std::out_of_range& e) {
16020       {
16021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16022       };
16023     } catch (std::exception& e) {
16024       {
16025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16026       };
16027     } catch (Dali::DaliException e) {
16028       {
16029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16030       };
16031     } catch (...) {
16032       {
16033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16034       };
16035     }
16036   }
16037
16038 }
16039
16040
16041 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
16042   void * jresult ;
16043   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16044   char *arg2 = (char *) 0 ;
16045   Dali::Property::Value *arg3 = 0 ;
16046   Dali::Property::Map *result = 0 ;
16047
16048   arg1 = (Dali::Property::Map *)jarg1;
16049   arg2 = (char *)jarg2;
16050   arg3 = (Dali::Property::Value *)jarg3;
16051   if (!arg3) {
16052     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
16053     return 0;
16054   }
16055   {
16056     try {
16057       result = (Dali::Property::Map *) &(arg1)->Add((char const *)arg2,(Dali::Property::Value const &)*arg3);
16058     } catch (std::out_of_range& e) {
16059       {
16060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16061       };
16062     } catch (std::exception& e) {
16063       {
16064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16065       };
16066     } catch (Dali::DaliException e) {
16067       {
16068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16069       };
16070     } catch (...) {
16071       {
16072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16073       };
16074     }
16075   }
16076
16077   jresult = (void *)result;
16078   return jresult;
16079 }
16080
16081
16082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
16083   void * jresult ;
16084   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16085   Dali::Property::Index arg2 ;
16086   Dali::Property::Value *arg3 = 0 ;
16087   Dali::Property::Map *result = 0 ;
16088
16089   arg1 = (Dali::Property::Map *)jarg1;
16090   arg2 = (Dali::Property::Index)jarg2;
16091   arg3 = (Dali::Property::Value *)jarg3;
16092   if (!arg3) {
16093     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
16094     return 0;
16095   }
16096   {
16097     try {
16098       result = (Dali::Property::Map *) &(arg1)->Add(arg2,(Dali::Property::Value const &)*arg3);
16099     } catch (std::out_of_range& e) {
16100       {
16101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16102       };
16103     } catch (std::exception& e) {
16104       {
16105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16106       };
16107     } catch (Dali::DaliException e) {
16108       {
16109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16110       };
16111     } catch (...) {
16112       {
16113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16114       };
16115     }
16116   }
16117
16118   jresult = (void *)result;
16119   return jresult;
16120 }
16121
16122
16123 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetValue(void * jarg1, unsigned long jarg2) {
16124   void * jresult ;
16125   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16126   Dali::Property::Map::SizeType arg2 ;
16127   Dali::Property::Value *result = 0 ;
16128
16129   arg1 = (Dali::Property::Map *)jarg1;
16130   arg2 = (Dali::Property::Map::SizeType)jarg2;
16131   {
16132     try {
16133       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->GetValue(arg2);
16134     } catch (std::out_of_range& e) {
16135       {
16136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16137       };
16138     } catch (std::exception& e) {
16139       {
16140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16141       };
16142     } catch (Dali::DaliException e) {
16143       {
16144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16145       };
16146     } catch (...) {
16147       {
16148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16149       };
16150     }
16151   }
16152
16153   jresult = (void *)result;
16154   return jresult;
16155 }
16156
16157
16158 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Map_GetKey(void * jarg1, unsigned long jarg2) {
16159   char * jresult ;
16160   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16161   Dali::Property::Map::SizeType arg2 ;
16162   std::string *result = 0 ;
16163
16164   arg1 = (Dali::Property::Map *)jarg1;
16165   arg2 = (Dali::Property::Map::SizeType)jarg2;
16166   {
16167     try {
16168       result = (std::string *) &((Dali::Property::Map const *)arg1)->GetKey(arg2);
16169     } catch (std::out_of_range& e) {
16170       {
16171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16172       };
16173     } catch (std::exception& e) {
16174       {
16175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16176       };
16177     } catch (Dali::DaliException e) {
16178       {
16179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16180       };
16181     } catch (...) {
16182       {
16183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16184       };
16185     }
16186   }
16187
16188   jresult = SWIG_csharp_string_callback(result->c_str());
16189   return jresult;
16190 }
16191
16192
16193 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetKeyAt(void * jarg1, unsigned long jarg2) {
16194   void * jresult ;
16195   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16196   Dali::Property::Map::SizeType arg2 ;
16197   SwigValueWrapper< Dali::Property::Key > result;
16198
16199   arg1 = (Dali::Property::Map *)jarg1;
16200   arg2 = (Dali::Property::Map::SizeType)jarg2;
16201   {
16202     try {
16203       result = ((Dali::Property::Map const *)arg1)->GetKeyAt(arg2);
16204     } catch (std::out_of_range& e) {
16205       {
16206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16207       };
16208     } catch (std::exception& e) {
16209       {
16210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16211       };
16212     } catch (Dali::DaliException e) {
16213       {
16214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16215       };
16216     } catch (...) {
16217       {
16218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16219       };
16220     }
16221   }
16222
16223   jresult = new Dali::Property::Key((const Dali::Property::Key &)result);
16224   return jresult;
16225 }
16226
16227
16228 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetPair(void * jarg1, unsigned long jarg2) {
16229   void * jresult ;
16230   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16231   Dali::Property::Map::SizeType arg2 ;
16232   StringValuePair *result = 0 ;
16233
16234   arg1 = (Dali::Property::Map *)jarg1;
16235   arg2 = (Dali::Property::Map::SizeType)jarg2;
16236   {
16237     try {
16238       result = (StringValuePair *) &((Dali::Property::Map const *)arg1)->GetPair(arg2);
16239     } catch (std::out_of_range& e) {
16240       {
16241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16242       };
16243     } catch (std::exception& e) {
16244       {
16245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16246       };
16247     } catch (Dali::DaliException e) {
16248       {
16249         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16250       };
16251     } catch (...) {
16252       {
16253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16254       };
16255     }
16256   }
16257
16258   jresult = (void *)result;
16259   return jresult;
16260 }
16261
16262
16263 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_0(void * jarg1, char * jarg2) {
16264   void * jresult ;
16265   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16266   char *arg2 = (char *) 0 ;
16267   Dali::Property::Value *result = 0 ;
16268
16269   arg1 = (Dali::Property::Map *)jarg1;
16270   arg2 = (char *)jarg2;
16271   {
16272     try {
16273       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((char const *)arg2);
16274     } catch (std::out_of_range& e) {
16275       {
16276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16277       };
16278     } catch (std::exception& e) {
16279       {
16280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16281       };
16282     } catch (Dali::DaliException e) {
16283       {
16284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16285       };
16286     } catch (...) {
16287       {
16288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16289       };
16290     }
16291   }
16292
16293   jresult = (void *)result;
16294   return jresult;
16295 }
16296
16297
16298 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_2(void * jarg1, int jarg2) {
16299   void * jresult ;
16300   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16301   Dali::Property::Index arg2 ;
16302   Dali::Property::Value *result = 0 ;
16303
16304   arg1 = (Dali::Property::Map *)jarg1;
16305   arg2 = (Dali::Property::Index)jarg2;
16306   {
16307     try {
16308       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2);
16309     } catch (std::out_of_range& e) {
16310       {
16311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16312       };
16313     } catch (std::exception& e) {
16314       {
16315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16316       };
16317     } catch (Dali::DaliException e) {
16318       {
16319         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16320       };
16321     } catch (...) {
16322       {
16323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16324       };
16325     }
16326   }
16327
16328   jresult = (void *)result;
16329   return jresult;
16330 }
16331
16332
16333 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_3(void * jarg1, int jarg2, char * jarg3) {
16334   void * jresult ;
16335   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16336   Dali::Property::Index arg2 ;
16337   std::string *arg3 = 0 ;
16338   Dali::Property::Value *result = 0 ;
16339
16340   arg1 = (Dali::Property::Map *)jarg1;
16341   arg2 = (Dali::Property::Index)jarg2;
16342   if (!jarg3) {
16343     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16344     return 0;
16345   }
16346   std::string arg3_str(jarg3);
16347   arg3 = &arg3_str;
16348   {
16349     try {
16350       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,(std::string const &)*arg3);
16351     } catch (std::out_of_range& e) {
16352       {
16353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16354       };
16355     } catch (std::exception& e) {
16356       {
16357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16358       };
16359     } catch (Dali::DaliException e) {
16360       {
16361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16362       };
16363     } catch (...) {
16364       {
16365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16366       };
16367     }
16368   }
16369
16370   jresult = (void *)result;
16371
16372   //argout typemap for const std::string&
16373
16374   return jresult;
16375 }
16376
16377
16378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_4(void * jarg1, char * jarg2, int jarg3) {
16379   void * jresult ;
16380   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16381   std::string *arg2 = 0 ;
16382   Dali::Property::Type arg3 ;
16383   Dali::Property::Value *result = 0 ;
16384
16385   arg1 = (Dali::Property::Map *)jarg1;
16386   if (!jarg2) {
16387     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16388     return 0;
16389   }
16390   std::string arg2_str(jarg2);
16391   arg2 = &arg2_str;
16392   arg3 = (Dali::Property::Type)jarg3;
16393   {
16394     try {
16395       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((std::string const &)*arg2,arg3);
16396     } catch (std::out_of_range& e) {
16397       {
16398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16399       };
16400     } catch (std::exception& e) {
16401       {
16402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16403       };
16404     } catch (Dali::DaliException e) {
16405       {
16406         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16407       };
16408     } catch (...) {
16409       {
16410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16411       };
16412     }
16413   }
16414
16415   jresult = (void *)result;
16416
16417   //argout typemap for const std::string&
16418
16419   return jresult;
16420 }
16421
16422
16423 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_5(void * jarg1, int jarg2, int jarg3) {
16424   void * jresult ;
16425   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16426   Dali::Property::Index arg2 ;
16427   Dali::Property::Type arg3 ;
16428   Dali::Property::Value *result = 0 ;
16429
16430   arg1 = (Dali::Property::Map *)jarg1;
16431   arg2 = (Dali::Property::Index)jarg2;
16432   arg3 = (Dali::Property::Type)jarg3;
16433   {
16434     try {
16435       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,arg3);
16436     } catch (std::out_of_range& e) {
16437       {
16438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16439       };
16440     } catch (std::exception& e) {
16441       {
16442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16443       };
16444     } catch (Dali::DaliException e) {
16445       {
16446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16447       };
16448     } catch (...) {
16449       {
16450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16451       };
16452     }
16453   }
16454
16455   jresult = (void *)result;
16456   return jresult;
16457 }
16458
16459
16460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Clear(void * jarg1) {
16461   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16462
16463   arg1 = (Dali::Property::Map *)jarg1;
16464   {
16465     try {
16466       (arg1)->Clear();
16467     } catch (std::out_of_range& e) {
16468       {
16469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16470       };
16471     } catch (std::exception& e) {
16472       {
16473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16474       };
16475     } catch (Dali::DaliException e) {
16476       {
16477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16478       };
16479     } catch (...) {
16480       {
16481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16482       };
16483     }
16484   }
16485
16486 }
16487
16488
16489 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Merge(void * jarg1, void * jarg2) {
16490   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16491   Dali::Property::Map *arg2 = 0 ;
16492
16493   arg1 = (Dali::Property::Map *)jarg1;
16494   arg2 = (Dali::Property::Map *)jarg2;
16495   if (!arg2) {
16496     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
16497     return ;
16498   }
16499   {
16500     try {
16501       (arg1)->Merge((Dali::Property::Map const &)*arg2);
16502     } catch (std::out_of_range& e) {
16503       {
16504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16505       };
16506     } catch (std::exception& e) {
16507       {
16508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16509       };
16510     } catch (Dali::DaliException e) {
16511       {
16512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16513       };
16514     } catch (...) {
16515       {
16516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16517       };
16518     }
16519   }
16520
16521 }
16522
16523
16524 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_0(void * jarg1, char * jarg2) {
16525   void * jresult ;
16526   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16527   std::string *arg2 = 0 ;
16528   Dali::Property::Value *result = 0 ;
16529
16530   arg1 = (Dali::Property::Map *)jarg1;
16531   if (!jarg2) {
16532     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16533     return 0;
16534   }
16535   std::string arg2_str(jarg2);
16536   arg2 = &arg2_str;
16537   {
16538     try {
16539       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator []((std::string const &)*arg2);
16540     } catch (std::out_of_range& e) {
16541       {
16542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16543       };
16544     } catch (std::exception& e) {
16545       {
16546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16547       };
16548     } catch (Dali::DaliException e) {
16549       {
16550         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16551       };
16552     } catch (...) {
16553       {
16554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16555       };
16556     }
16557   }
16558
16559   jresult = (void *)result;
16560
16561   //argout typemap for const std::string&
16562
16563   return jresult;
16564 }
16565
16566
16567 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_2(void * jarg1, int jarg2) {
16568   void * jresult ;
16569   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16570   Dali::Property::Index arg2 ;
16571   Dali::Property::Value *result = 0 ;
16572
16573   arg1 = (Dali::Property::Map *)jarg1;
16574   arg2 = (Dali::Property::Index)jarg2;
16575   {
16576     try {
16577       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator [](arg2);
16578     } catch (std::out_of_range& e) {
16579       {
16580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16581       };
16582     } catch (std::exception& e) {
16583       {
16584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16585       };
16586     } catch (Dali::DaliException e) {
16587       {
16588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16589       };
16590     } catch (...) {
16591       {
16592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16593       };
16594     }
16595   }
16596
16597   jresult = (void *)result;
16598   return jresult;
16599 }
16600
16601
16602 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Assign(void * jarg1, void * jarg2) {
16603   void * jresult ;
16604   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16605   Dali::Property::Map *arg2 = 0 ;
16606   Dali::Property::Map *result = 0 ;
16607
16608   arg1 = (Dali::Property::Map *)jarg1;
16609   arg2 = (Dali::Property::Map *)jarg2;
16610   if (!arg2) {
16611     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
16612     return 0;
16613   }
16614   {
16615     try {
16616       result = (Dali::Property::Map *) &(arg1)->operator =((Dali::Property::Map const &)*arg2);
16617     } catch (std::out_of_range& e) {
16618       {
16619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16620       };
16621     } catch (std::exception& e) {
16622       {
16623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16624       };
16625     } catch (Dali::DaliException e) {
16626       {
16627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16628       };
16629     } catch (...) {
16630       {
16631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16632       };
16633     }
16634   }
16635
16636   jresult = (void *)result;
16637   return jresult;
16638 }
16639
16640
16641 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_0() {
16642   void * jresult ;
16643   Dali::Property::Value *result = 0 ;
16644
16645   {
16646     try {
16647       result = (Dali::Property::Value *)new Dali::Property::Value();
16648     } catch (std::out_of_range& e) {
16649       {
16650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16651       };
16652     } catch (std::exception& e) {
16653       {
16654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16655       };
16656     } catch (Dali::DaliException e) {
16657       {
16658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16659       };
16660     } catch (...) {
16661       {
16662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16663       };
16664     }
16665   }
16666
16667   jresult = (void *)result;
16668   return jresult;
16669 }
16670
16671
16672 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_1(unsigned int jarg1) {
16673   void * jresult ;
16674   bool arg1 ;
16675   Dali::Property::Value *result = 0 ;
16676
16677   arg1 = jarg1 ? true : false;
16678   {
16679     try {
16680       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16681     } catch (std::out_of_range& e) {
16682       {
16683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16684       };
16685     } catch (std::exception& e) {
16686       {
16687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16688       };
16689     } catch (Dali::DaliException e) {
16690       {
16691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16692       };
16693     } catch (...) {
16694       {
16695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16696       };
16697     }
16698   }
16699
16700   jresult = (void *)result;
16701   return jresult;
16702 }
16703
16704
16705 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_2(int jarg1) {
16706   void * jresult ;
16707   int arg1 ;
16708   Dali::Property::Value *result = 0 ;
16709
16710   arg1 = (int)jarg1;
16711   {
16712     try {
16713       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16714     } catch (std::out_of_range& e) {
16715       {
16716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16717       };
16718     } catch (std::exception& e) {
16719       {
16720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16721       };
16722     } catch (Dali::DaliException e) {
16723       {
16724         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16725       };
16726     } catch (...) {
16727       {
16728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16729       };
16730     }
16731   }
16732
16733   jresult = (void *)result;
16734   return jresult;
16735 }
16736
16737
16738 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_3(float jarg1) {
16739   void * jresult ;
16740   float arg1 ;
16741   Dali::Property::Value *result = 0 ;
16742
16743   arg1 = (float)jarg1;
16744   {
16745     try {
16746       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16747     } catch (std::out_of_range& e) {
16748       {
16749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16750       };
16751     } catch (std::exception& e) {
16752       {
16753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16754       };
16755     } catch (Dali::DaliException e) {
16756       {
16757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16758       };
16759     } catch (...) {
16760       {
16761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16762       };
16763     }
16764   }
16765
16766   jresult = (void *)result;
16767   return jresult;
16768 }
16769
16770
16771 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_4(void * jarg1) {
16772   void * jresult ;
16773   Dali::Vector2 *arg1 = 0 ;
16774   Dali::Property::Value *result = 0 ;
16775
16776   arg1 = (Dali::Vector2 *)jarg1;
16777   if (!arg1) {
16778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
16779     return 0;
16780   }
16781   {
16782     try {
16783       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector2 const &)*arg1);
16784     } catch (std::out_of_range& e) {
16785       {
16786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16787       };
16788     } catch (std::exception& e) {
16789       {
16790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16791       };
16792     } catch (Dali::DaliException e) {
16793       {
16794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16795       };
16796     } catch (...) {
16797       {
16798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16799       };
16800     }
16801   }
16802
16803   jresult = (void *)result;
16804   return jresult;
16805 }
16806
16807
16808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_5(void * jarg1) {
16809   void * jresult ;
16810   Dali::Vector3 *arg1 = 0 ;
16811   Dali::Property::Value *result = 0 ;
16812
16813   arg1 = (Dali::Vector3 *)jarg1;
16814   if (!arg1) {
16815     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
16816     return 0;
16817   }
16818   {
16819     try {
16820       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector3 const &)*arg1);
16821     } catch (std::out_of_range& e) {
16822       {
16823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16824       };
16825     } catch (std::exception& e) {
16826       {
16827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16828       };
16829     } catch (Dali::DaliException e) {
16830       {
16831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16832       };
16833     } catch (...) {
16834       {
16835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16836       };
16837     }
16838   }
16839
16840   jresult = (void *)result;
16841   return jresult;
16842 }
16843
16844
16845 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_6(void * jarg1) {
16846   void * jresult ;
16847   Dali::Vector4 *arg1 = 0 ;
16848   Dali::Property::Value *result = 0 ;
16849
16850   arg1 = (Dali::Vector4 *)jarg1;
16851   if (!arg1) {
16852     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
16853     return 0;
16854   }
16855   {
16856     try {
16857       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector4 const &)*arg1);
16858     } catch (std::out_of_range& e) {
16859       {
16860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16861       };
16862     } catch (std::exception& e) {
16863       {
16864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16865       };
16866     } catch (Dali::DaliException e) {
16867       {
16868         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16869       };
16870     } catch (...) {
16871       {
16872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16873       };
16874     }
16875   }
16876
16877   jresult = (void *)result;
16878   return jresult;
16879 }
16880
16881
16882 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_7(void * jarg1) {
16883   void * jresult ;
16884   Dali::Matrix3 *arg1 = 0 ;
16885   Dali::Property::Value *result = 0 ;
16886
16887   arg1 = (Dali::Matrix3 *)jarg1;
16888   if (!arg1) {
16889     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
16890     return 0;
16891   }
16892   {
16893     try {
16894       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix3 const &)*arg1);
16895     } catch (std::out_of_range& e) {
16896       {
16897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16898       };
16899     } catch (std::exception& e) {
16900       {
16901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16902       };
16903     } catch (Dali::DaliException e) {
16904       {
16905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16906       };
16907     } catch (...) {
16908       {
16909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16910       };
16911     }
16912   }
16913
16914   jresult = (void *)result;
16915   return jresult;
16916 }
16917
16918
16919 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_8(void * jarg1) {
16920   void * jresult ;
16921   Dali::Matrix *arg1 = 0 ;
16922   Dali::Property::Value *result = 0 ;
16923
16924   arg1 = (Dali::Matrix *)jarg1;
16925   if (!arg1) {
16926     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
16927     return 0;
16928   }
16929   {
16930     try {
16931       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix const &)*arg1);
16932     } catch (std::out_of_range& e) {
16933       {
16934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16935       };
16936     } catch (std::exception& e) {
16937       {
16938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16939       };
16940     } catch (Dali::DaliException e) {
16941       {
16942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16943       };
16944     } catch (...) {
16945       {
16946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16947       };
16948     }
16949   }
16950
16951   jresult = (void *)result;
16952   return jresult;
16953 }
16954
16955
16956 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_9(void * jarg1) {
16957   void * jresult ;
16958   Dali::Rect< int > *arg1 = 0 ;
16959   Dali::Property::Value *result = 0 ;
16960
16961   arg1 = (Dali::Rect< int > *)jarg1;
16962   if (!arg1) {
16963     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
16964     return 0;
16965   }
16966   {
16967     try {
16968       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Rect< int > const &)*arg1);
16969     } catch (std::out_of_range& e) {
16970       {
16971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16972       };
16973     } catch (std::exception& e) {
16974       {
16975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16976       };
16977     } catch (Dali::DaliException e) {
16978       {
16979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16980       };
16981     } catch (...) {
16982       {
16983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16984       };
16985     }
16986   }
16987
16988   jresult = (void *)result;
16989   return jresult;
16990 }
16991
16992
16993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_10(void * jarg1) {
16994   void * jresult ;
16995   Dali::AngleAxis *arg1 = 0 ;
16996   Dali::Property::Value *result = 0 ;
16997
16998   arg1 = (Dali::AngleAxis *)jarg1;
16999   if (!arg1) {
17000     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
17001     return 0;
17002   }
17003   {
17004     try {
17005       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::AngleAxis const &)*arg1);
17006     } catch (std::out_of_range& e) {
17007       {
17008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17009       };
17010     } catch (std::exception& e) {
17011       {
17012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17013       };
17014     } catch (Dali::DaliException e) {
17015       {
17016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17017       };
17018     } catch (...) {
17019       {
17020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17021       };
17022     }
17023   }
17024
17025   jresult = (void *)result;
17026   return jresult;
17027 }
17028
17029
17030 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_11(void * jarg1) {
17031   void * jresult ;
17032   Dali::Quaternion *arg1 = 0 ;
17033   Dali::Property::Value *result = 0 ;
17034
17035   arg1 = (Dali::Quaternion *)jarg1;
17036   if (!arg1) {
17037     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
17038     return 0;
17039   }
17040   {
17041     try {
17042       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Quaternion const &)*arg1);
17043     } catch (std::out_of_range& e) {
17044       {
17045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17046       };
17047     } catch (std::exception& e) {
17048       {
17049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17050       };
17051     } catch (Dali::DaliException e) {
17052       {
17053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17054       };
17055     } catch (...) {
17056       {
17057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17058       };
17059     }
17060   }
17061
17062   jresult = (void *)result;
17063   return jresult;
17064 }
17065
17066
17067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_12(char * jarg1) {
17068   void * jresult ;
17069   std::string *arg1 = 0 ;
17070   Dali::Property::Value *result = 0 ;
17071
17072   if (!jarg1) {
17073     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
17074     return 0;
17075   }
17076   std::string arg1_str(jarg1);
17077   arg1 = &arg1_str;
17078   {
17079     try {
17080       result = (Dali::Property::Value *)new Dali::Property::Value((std::string const &)*arg1);
17081     } catch (std::out_of_range& e) {
17082       {
17083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17084       };
17085     } catch (std::exception& e) {
17086       {
17087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17088       };
17089     } catch (Dali::DaliException e) {
17090       {
17091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17092       };
17093     } catch (...) {
17094       {
17095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17096       };
17097     }
17098   }
17099
17100   jresult = (void *)result;
17101
17102   //argout typemap for const std::string&
17103
17104   return jresult;
17105 }
17106
17107
17108 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_14(void * jarg1) {
17109   void * jresult ;
17110   Dali::Property::Array *arg1 = 0 ;
17111   Dali::Property::Value *result = 0 ;
17112
17113   arg1 = (Dali::Property::Array *)jarg1;
17114   if (!arg1) {
17115     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
17116     return 0;
17117   }
17118   {
17119     try {
17120       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
17121     } catch (std::out_of_range& e) {
17122       {
17123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17124       };
17125     } catch (std::exception& e) {
17126       {
17127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17128       };
17129     } catch (Dali::DaliException e) {
17130       {
17131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17132       };
17133     } catch (...) {
17134       {
17135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17136       };
17137     }
17138   }
17139
17140   jresult = (void *)result;
17141   return jresult;
17142 }
17143
17144
17145 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_15(void * jarg1) {
17146   void * jresult ;
17147   Dali::Property::Map *arg1 = 0 ;
17148   Dali::Property::Value *result = 0 ;
17149
17150   arg1 = (Dali::Property::Map *)jarg1;
17151   if (!arg1) {
17152     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
17153     return 0;
17154   }
17155   {
17156     try {
17157       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
17158     } catch (std::out_of_range& e) {
17159       {
17160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17161       };
17162     } catch (std::exception& e) {
17163       {
17164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17165       };
17166     } catch (Dali::DaliException e) {
17167       {
17168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17169       };
17170     } catch (...) {
17171       {
17172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17173       };
17174     }
17175   }
17176
17177   jresult = (void *)result;
17178   return jresult;
17179 }
17180
17181
17182 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_16(void * jarg1) {
17183   void * jresult ;
17184   Extents *arg1 = 0 ;
17185   Dali::Property::Value *result = 0 ;
17186
17187   arg1 = (Extents *)jarg1;
17188   if (!arg1) {
17189     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Extents const & type is null", 0);
17190     return 0;
17191   }
17192   {
17193     try {
17194       result = (Dali::Property::Value *)new Dali::Property::Value((Extents const &)*arg1);
17195     } catch (std::out_of_range& e) {
17196       {
17197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17198       };
17199     } catch (std::exception& e) {
17200       {
17201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17202       };
17203     } catch (...) {
17204       {
17205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17206       };
17207     }
17208   }
17209   jresult = (void *)result;
17210   return jresult;
17211 }
17212
17213
17214 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_17(int jarg1) {
17215   void * jresult ;
17216   Dali::Property::Type arg1 ;
17217   Dali::Property::Value *result = 0 ;
17218
17219   arg1 = (Dali::Property::Type)jarg1;
17220   {
17221     try {
17222       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
17223     } catch (std::out_of_range& e) {
17224       {
17225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17226       };
17227     } catch (std::exception& e) {
17228       {
17229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17230       };
17231     } catch (Dali::DaliException e) {
17232       {
17233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17234       };
17235     } catch (...) {
17236       {
17237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17238       };
17239     }
17240   }
17241
17242   jresult = (void *)result;
17243   return jresult;
17244 }
17245
17246
17247 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_18(void * jarg1) {
17248   void * jresult ;
17249   Dali::Property::Value *arg1 = 0 ;
17250   Dali::Property::Value *result = 0 ;
17251
17252   arg1 = (Dali::Property::Value *)jarg1;
17253   if (!arg1) {
17254     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
17255     return 0;
17256   }
17257   {
17258     try {
17259       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Property::Value const &)*arg1);
17260     } catch (std::out_of_range& e) {
17261       {
17262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17263       };
17264     } catch (std::exception& e) {
17265       {
17266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17267       };
17268     } catch (Dali::DaliException e) {
17269       {
17270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17271       };
17272     } catch (...) {
17273       {
17274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17275       };
17276     }
17277   }
17278
17279   jresult = (void *)result;
17280   return jresult;
17281 }
17282
17283
17284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_Assign(void * jarg1, void * jarg2) {
17285   void * jresult ;
17286   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17287   Dali::Property::Value *arg2 = 0 ;
17288   Dali::Property::Value *result = 0 ;
17289
17290   arg1 = (Dali::Property::Value *)jarg1;
17291   arg2 = (Dali::Property::Value *)jarg2;
17292   if (!arg2) {
17293     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
17294     return 0;
17295   }
17296   {
17297     try {
17298       result = (Dali::Property::Value *) &(arg1)->operator =((Dali::Property::Value const &)*arg2);
17299     } catch (std::out_of_range& e) {
17300       {
17301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17302       };
17303     } catch (std::exception& e) {
17304       {
17305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17306       };
17307     } catch (Dali::DaliException e) {
17308       {
17309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17310       };
17311     } catch (...) {
17312       {
17313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17314       };
17315     }
17316   }
17317
17318   jresult = (void *)result;
17319   return jresult;
17320 }
17321
17322
17323 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Value(void * jarg1) {
17324   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17325
17326   arg1 = (Dali::Property::Value *)jarg1;
17327   {
17328     try {
17329       delete arg1;
17330     } catch (std::out_of_range& e) {
17331       {
17332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17333       };
17334     } catch (std::exception& e) {
17335       {
17336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17337       };
17338     } catch (Dali::DaliException e) {
17339       {
17340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
17341       };
17342     } catch (...) {
17343       {
17344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17345       };
17346     }
17347   }
17348
17349 }
17350
17351
17352 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Value_GetType(void * jarg1) {
17353   int jresult ;
17354   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17355   Dali::Property::Type result;
17356
17357   arg1 = (Dali::Property::Value *)jarg1;
17358   {
17359     try {
17360       result = (Dali::Property::Type)((Dali::Property::Value const *)arg1)->GetType();
17361     } catch (std::out_of_range& e) {
17362       {
17363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17364       };
17365     } catch (std::exception& e) {
17366       {
17367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17368       };
17369     } catch (Dali::DaliException e) {
17370       {
17371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17372       };
17373     } catch (...) {
17374       {
17375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17376       };
17377     }
17378   }
17379
17380   jresult = (int)result;
17381   return jresult;
17382 }
17383
17384
17385 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_1(void * jarg1, unsigned int * jarg2) {
17386   unsigned int jresult ;
17387   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17388   bool *arg2 = 0 ;
17389   bool result;
17390
17391   arg1 = (Dali::Property::Value *)jarg1;
17392   arg2 = (bool *)jarg2;
17393   {
17394     try {
17395       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17396     } catch (std::out_of_range& e) {
17397       {
17398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17399       };
17400     } catch (std::exception& e) {
17401       {
17402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17403       };
17404     } catch (Dali::DaliException e) {
17405       {
17406         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17407       };
17408     } catch (...) {
17409       {
17410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17411       };
17412     }
17413   }
17414
17415   jresult = result;
17416   return jresult;
17417 }
17418
17419
17420 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_2(void * jarg1, float * jarg2) {
17421   unsigned int jresult ;
17422   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17423   float *arg2 = 0 ;
17424   bool result;
17425
17426   arg1 = (Dali::Property::Value *)jarg1;
17427   arg2 = (float *)jarg2;
17428   {
17429     try {
17430       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17431     } catch (std::out_of_range& e) {
17432       {
17433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17434       };
17435     } catch (std::exception& e) {
17436       {
17437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17438       };
17439     } catch (Dali::DaliException e) {
17440       {
17441         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17442       };
17443     } catch (...) {
17444       {
17445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17446       };
17447     }
17448   }
17449
17450   jresult = result;
17451   return jresult;
17452 }
17453
17454
17455 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_3(void * jarg1, int * jarg2) {
17456   unsigned int jresult ;
17457   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17458   int *arg2 = 0 ;
17459   bool result;
17460
17461   arg1 = (Dali::Property::Value *)jarg1;
17462   arg2 = (int *)jarg2;
17463   {
17464     try {
17465       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17466     } catch (std::out_of_range& e) {
17467       {
17468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17469       };
17470     } catch (std::exception& e) {
17471       {
17472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17473       };
17474     } catch (Dali::DaliException e) {
17475       {
17476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17477       };
17478     } catch (...) {
17479       {
17480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17481       };
17482     }
17483   }
17484
17485   jresult = result;
17486   return jresult;
17487 }
17488
17489
17490 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_4(void * jarg1, void * jarg2) {
17491   unsigned int jresult ;
17492   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17493   Dali::Rect< int > *arg2 = 0 ;
17494   bool result;
17495
17496   arg1 = (Dali::Property::Value *)jarg1;
17497   arg2 = (Dali::Rect< int > *)jarg2;
17498   if (!arg2) {
17499     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > & type is null", 0);
17500     return 0;
17501   }
17502   {
17503     try {
17504       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17505     } catch (std::out_of_range& e) {
17506       {
17507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17508       };
17509     } catch (std::exception& e) {
17510       {
17511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17512       };
17513     } catch (Dali::DaliException e) {
17514       {
17515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17516       };
17517     } catch (...) {
17518       {
17519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17520       };
17521     }
17522   }
17523
17524   jresult = result;
17525   return jresult;
17526 }
17527
17528
17529 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_5(void * jarg1, void * jarg2) {
17530   unsigned int jresult ;
17531   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17532   Dali::Vector2 *arg2 = 0 ;
17533   bool result;
17534
17535   arg1 = (Dali::Property::Value *)jarg1;
17536   arg2 = (Dali::Vector2 *)jarg2;
17537   if (!arg2) {
17538     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
17539     return 0;
17540   }
17541   {
17542     try {
17543       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17544     } catch (std::out_of_range& e) {
17545       {
17546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17547       };
17548     } catch (std::exception& e) {
17549       {
17550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17551       };
17552     } catch (Dali::DaliException e) {
17553       {
17554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17555       };
17556     } catch (...) {
17557       {
17558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17559       };
17560     }
17561   }
17562
17563   jresult = result;
17564   return jresult;
17565 }
17566
17567
17568 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_6(void * jarg1, void * jarg2) {
17569   unsigned int jresult ;
17570   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17571   Dali::Vector3 *arg2 = 0 ;
17572   bool result;
17573
17574   arg1 = (Dali::Property::Value *)jarg1;
17575   arg2 = (Dali::Vector3 *)jarg2;
17576   if (!arg2) {
17577     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
17578     return 0;
17579   }
17580   {
17581     try {
17582       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17583     } catch (std::out_of_range& e) {
17584       {
17585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17586       };
17587     } catch (std::exception& e) {
17588       {
17589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17590       };
17591     } catch (Dali::DaliException e) {
17592       {
17593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17594       };
17595     } catch (...) {
17596       {
17597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17598       };
17599     }
17600   }
17601
17602   jresult = result;
17603   return jresult;
17604 }
17605
17606
17607 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_7(void * jarg1, void * jarg2) {
17608   unsigned int jresult ;
17609   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17610   Dali::Vector4 *arg2 = 0 ;
17611   bool result;
17612
17613   arg1 = (Dali::Property::Value *)jarg1;
17614   arg2 = (Dali::Vector4 *)jarg2;
17615   if (!arg2) {
17616     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 & type is null", 0);
17617     return 0;
17618   }
17619   {
17620     try {
17621       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17622     } catch (std::out_of_range& e) {
17623       {
17624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17625       };
17626     } catch (std::exception& e) {
17627       {
17628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17629       };
17630     } catch (Dali::DaliException e) {
17631       {
17632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17633       };
17634     } catch (...) {
17635       {
17636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17637       };
17638     }
17639   }
17640
17641   jresult = result;
17642   return jresult;
17643 }
17644
17645
17646 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_8(void * jarg1, void * jarg2) {
17647   unsigned int jresult ;
17648   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17649   Dali::Matrix3 *arg2 = 0 ;
17650   bool result;
17651
17652   arg1 = (Dali::Property::Value *)jarg1;
17653   arg2 = (Dali::Matrix3 *)jarg2;
17654   if (!arg2) {
17655     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
17656     return 0;
17657   }
17658   {
17659     try {
17660       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17661     } catch (std::out_of_range& e) {
17662       {
17663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17664       };
17665     } catch (std::exception& e) {
17666       {
17667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17668       };
17669     } catch (Dali::DaliException e) {
17670       {
17671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17672       };
17673     } catch (...) {
17674       {
17675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17676       };
17677     }
17678   }
17679
17680   jresult = result;
17681   return jresult;
17682 }
17683
17684
17685 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_9(void * jarg1, void * jarg2) {
17686   unsigned int jresult ;
17687   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17688   Dali::Matrix *arg2 = 0 ;
17689   bool result;
17690
17691   arg1 = (Dali::Property::Value *)jarg1;
17692   arg2 = (Dali::Matrix *)jarg2;
17693   if (!arg2) {
17694     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
17695     return 0;
17696   }
17697   {
17698     try {
17699       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17700     } catch (std::out_of_range& e) {
17701       {
17702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17703       };
17704     } catch (std::exception& e) {
17705       {
17706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17707       };
17708     } catch (Dali::DaliException e) {
17709       {
17710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17711       };
17712     } catch (...) {
17713       {
17714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17715       };
17716     }
17717   }
17718
17719   jresult = result;
17720   return jresult;
17721 }
17722
17723
17724 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_10(void * jarg1, void * jarg2) {
17725   unsigned int jresult ;
17726   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17727   Dali::AngleAxis *arg2 = 0 ;
17728   bool result;
17729
17730   arg1 = (Dali::Property::Value *)jarg1;
17731   arg2 = (Dali::AngleAxis *)jarg2;
17732   if (!arg2) {
17733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis & type is null", 0);
17734     return 0;
17735   }
17736   {
17737     try {
17738       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17739     } catch (std::out_of_range& e) {
17740       {
17741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17742       };
17743     } catch (std::exception& e) {
17744       {
17745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17746       };
17747     } catch (Dali::DaliException e) {
17748       {
17749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17750       };
17751     } catch (...) {
17752       {
17753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17754       };
17755     }
17756   }
17757
17758   jresult = result;
17759   return jresult;
17760 }
17761
17762
17763 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_11(void * jarg1, void * jarg2) {
17764   unsigned int jresult ;
17765   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17766   Dali::Quaternion *arg2 = 0 ;
17767   bool result;
17768
17769   arg1 = (Dali::Property::Value *)jarg1;
17770   arg2 = (Dali::Quaternion *)jarg2;
17771   if (!arg2) {
17772     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
17773     return 0;
17774   }
17775   {
17776     try {
17777       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17778     } catch (std::out_of_range& e) {
17779       {
17780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17781       };
17782     } catch (std::exception& e) {
17783       {
17784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17785       };
17786     } catch (Dali::DaliException e) {
17787       {
17788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17789       };
17790     } catch (...) {
17791       {
17792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17793       };
17794     }
17795   }
17796
17797   jresult = result;
17798   return jresult;
17799 }
17800
17801
17802 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_12(void * jarg1, char** jarg2) {
17803   unsigned int jresult ;
17804   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17805   std::string *arg2 = 0 ;
17806   bool result;
17807
17808   arg1 = (Dali::Property::Value *)jarg1;
17809
17810   //typemap in
17811   std::string temp;
17812   arg2 = &temp;
17813
17814   {
17815     try {
17816       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17817     } catch (std::out_of_range& e) {
17818       {
17819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17820       };
17821     } catch (std::exception& e) {
17822       {
17823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17824       };
17825     } catch (Dali::DaliException e) {
17826       {
17827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17828       };
17829     } catch (...) {
17830       {
17831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17832       };
17833     }
17834   }
17835
17836   jresult = result;
17837
17838   //Typemap argout in c++ file.
17839   //This will convert c++ string to c# string
17840   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
17841
17842   return jresult;
17843 }
17844
17845
17846 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_13(void * jarg1, void * jarg2) {
17847   unsigned int jresult ;
17848   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17849   Dali::Property::Array *arg2 = 0 ;
17850   bool result;
17851
17852   arg1 = (Dali::Property::Value *)jarg1;
17853   arg2 = (Dali::Property::Array *)jarg2;
17854   if (!arg2) {
17855     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
17856     return 0;
17857   }
17858   {
17859     try {
17860       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17861     } catch (std::out_of_range& e) {
17862       {
17863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17864       };
17865     } catch (std::exception& e) {
17866       {
17867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17868       };
17869     } catch (Dali::DaliException e) {
17870       {
17871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17872       };
17873     } catch (...) {
17874       {
17875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17876       };
17877     }
17878   }
17879
17880   jresult = result;
17881   return jresult;
17882 }
17883
17884
17885 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_14(void * jarg1, void * jarg2) {
17886   unsigned int jresult ;
17887   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17888   Dali::Property::Map *arg2 = 0 ;
17889   bool result;
17890
17891   arg1 = (Dali::Property::Value *)jarg1;
17892   arg2 = (Dali::Property::Map *)jarg2;
17893   if (!arg2) {
17894     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
17895     return 0;
17896   }
17897   {
17898     try {
17899       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17900     } catch (std::out_of_range& e) {
17901       {
17902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17903       };
17904     } catch (std::exception& e) {
17905       {
17906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17907       };
17908     } catch (Dali::DaliException e) {
17909       {
17910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17911       };
17912     } catch (...) {
17913       {
17914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17915       };
17916     }
17917   }
17918
17919   jresult = result;
17920   return jresult;
17921 }
17922
17923
17924 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_15(void * jarg1, void * jarg2) {
17925   unsigned int jresult ;
17926   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17927   Extents *arg2 = 0 ;
17928   bool result;
17929
17930   arg1 = (Dali::Property::Value *)jarg1;
17931   arg2 = (Extents *)jarg2;
17932   if (!arg2) {
17933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Extents & type is null", 0);
17934     return 0;
17935   }
17936   {
17937     try {
17938       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17939     } catch (std::out_of_range& e) {
17940       {
17941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17942       };
17943     } catch (std::exception& e) {
17944       {
17945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17946       };
17947     } catch (...) {
17948       {
17949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17950       };
17951     }
17952   }
17953   jresult = result;
17954   return jresult;
17955 }
17956
17957
17958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetArray(void * jarg1) {
17959   void * jresult ;
17960   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17961   Dali::Property::Array *result = 0 ;
17962
17963   arg1 = (Dali::Property::Value *)jarg1;
17964   {
17965     try {
17966       result = (Dali::Property::Array *)((Dali::Property::Value const *)arg1)->GetArray();
17967     } catch (std::out_of_range& e) {
17968       {
17969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17970       };
17971     } catch (std::exception& e) {
17972       {
17973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17974       };
17975     } catch (Dali::DaliException e) {
17976       {
17977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17978       };
17979     } catch (...) {
17980       {
17981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17982       };
17983     }
17984   }
17985
17986   jresult = (void *)result;
17987   return jresult;
17988 }
17989
17990
17991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetMap(void * jarg1) {
17992   void * jresult ;
17993   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17994   Dali::Property::Map *result = 0 ;
17995
17996   arg1 = (Dali::Property::Value *)jarg1;
17997   {
17998     try {
17999       result = (Dali::Property::Map *)((Dali::Property::Value const *)arg1)->GetMap();
18000     } catch (std::out_of_range& e) {
18001       {
18002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18003       };
18004     } catch (std::exception& e) {
18005       {
18006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18007       };
18008     } catch (Dali::DaliException e) {
18009       {
18010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18011       };
18012     } catch (...) {
18013       {
18014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18015       };
18016     }
18017   }
18018
18019   jresult = (void *)result;
18020   return jresult;
18021 }
18022
18023
18024 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetName(int jarg1) {
18025   char * jresult ;
18026   Dali::Property::Type arg1 ;
18027   char *result = 0 ;
18028
18029   arg1 = (Dali::Property::Type)jarg1;
18030   {
18031     try {
18032       result = (char *)Dali::PropertyTypes::GetName(arg1);
18033     } catch (std::out_of_range& e) {
18034       {
18035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18036       };
18037     } catch (std::exception& e) {
18038       {
18039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18040       };
18041     } catch (Dali::DaliException e) {
18042       {
18043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18044       };
18045     } catch (...) {
18046       {
18047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18048       };
18049     }
18050   }
18051
18052   jresult = SWIG_csharp_string_callback((const char *)result);
18053   return jresult;
18054 }
18055
18056
18057 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoAction(void * jarg1, char * jarg2, void * jarg3) {
18058   unsigned int jresult ;
18059   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18060   std::string *arg2 = 0 ;
18061   Dali::Property::Map *arg3 = 0 ;
18062   bool result;
18063
18064   arg1 = (Dali::BaseObject *)jarg1;
18065   if (!jarg2) {
18066     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18067     return 0;
18068   }
18069   std::string arg2_str(jarg2);
18070   arg2 = &arg2_str;
18071   arg3 = (Dali::Property::Map *)jarg3;
18072   if (!arg3) {
18073     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
18074     return 0;
18075   }
18076   {
18077     try {
18078       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
18079     } catch (std::out_of_range& e) {
18080       {
18081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18082       };
18083     } catch (std::exception& e) {
18084       {
18085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18086       };
18087     } catch (Dali::DaliException e) {
18088       {
18089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18090       };
18091     } catch (...) {
18092       {
18093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18094       };
18095     }
18096   }
18097
18098   jresult = result;
18099
18100   //argout typemap for const std::string&
18101
18102   return jresult;
18103 }
18104
18105
18106 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeName(void * jarg1) {
18107   char * jresult ;
18108   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18109   std::string *result = 0 ;
18110
18111   arg1 = (Dali::BaseObject *)jarg1;
18112   {
18113     try {
18114       result = (std::string *) &((Dali::BaseObject const *)arg1)->GetTypeName();
18115     } catch (std::out_of_range& e) {
18116       {
18117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18118       };
18119     } catch (std::exception& e) {
18120       {
18121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18122       };
18123     } catch (Dali::DaliException e) {
18124       {
18125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18126       };
18127     } catch (...) {
18128       {
18129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18130       };
18131     }
18132   }
18133
18134   jresult = SWIG_csharp_string_callback(result->c_str());
18135   return jresult;
18136 }
18137
18138
18139 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeInfo(void * jarg1, void * jarg2) {
18140   unsigned int jresult ;
18141   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18142   Dali::TypeInfo *arg2 = 0 ;
18143   bool result;
18144
18145   arg1 = (Dali::BaseObject *)jarg1;
18146   arg2 = (Dali::TypeInfo *)jarg2;
18147   if (!arg2) {
18148     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
18149     return 0;
18150   }
18151   {
18152     try {
18153       result = (bool)((Dali::BaseObject const *)arg1)->GetTypeInfo(*arg2);
18154     } catch (std::out_of_range& e) {
18155       {
18156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18157       };
18158     } catch (std::exception& e) {
18159       {
18160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18161       };
18162     } catch (Dali::DaliException e) {
18163       {
18164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18165       };
18166     } catch (...) {
18167       {
18168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18169       };
18170     }
18171   }
18172
18173   jresult = result;
18174   return jresult;
18175 }
18176
18177
18178 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoConnectSignal(void * jarg1, void * jarg2, char * jarg3, void * jarg4) {
18179   unsigned int jresult ;
18180   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18181   ConnectionTrackerInterface *arg2 = (ConnectionTrackerInterface *) 0 ;
18182   std::string *arg3 = 0 ;
18183   FunctorDelegate *arg4 = (FunctorDelegate *) 0 ;
18184   bool result;
18185
18186   arg1 = (Dali::BaseObject *)jarg1;
18187   arg2 = (ConnectionTrackerInterface *)jarg2;
18188   if (!jarg3) {
18189     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18190     return 0;
18191   }
18192   std::string arg3_str(jarg3);
18193   arg3 = &arg3_str;
18194   arg4 = (FunctorDelegate *)jarg4;
18195   {
18196     try {
18197       result = (bool)(arg1)->DoConnectSignal(arg2,(std::string const &)*arg3,arg4);
18198     } catch (std::out_of_range& e) {
18199       {
18200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18201       };
18202     } catch (std::exception& e) {
18203       {
18204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18205       };
18206     } catch (Dali::DaliException e) {
18207       {
18208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18209       };
18210     } catch (...) {
18211       {
18212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18213       };
18214     }
18215   }
18216
18217   jresult = result;
18218
18219   //argout typemap for const std::string&
18220
18221   return jresult;
18222 }
18223
18224
18225 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation(void * jarg1) {
18226   void * jresult ;
18227   Dali::BaseHandle *arg1 = 0 ;
18228   Dali::BaseObject *result = 0 ;
18229
18230   arg1 = (Dali::BaseHandle *)jarg1;
18231   if (!arg1) {
18232     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18233     return 0;
18234   }
18235   {
18236     try {
18237       result = (Dali::BaseObject *) &Dali::GetImplementation((Dali::BaseHandle const &)*arg1);
18238     } catch (std::out_of_range& e) {
18239       {
18240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18241       };
18242     } catch (std::exception& e) {
18243       {
18244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18245       };
18246     } catch (Dali::DaliException e) {
18247       {
18248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18249       };
18250     } catch (...) {
18251       {
18252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18253       };
18254     }
18255   }
18256
18257   jresult = (void *)result;
18258   return jresult;
18259 }
18260
18261
18262 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_0(void * jarg1) {
18263   void * jresult ;
18264   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18265   Dali::BaseHandle *result = 0 ;
18266
18267   arg1 = (Dali::BaseObject *)jarg1;
18268   {
18269     try {
18270       result = (Dali::BaseHandle *)new Dali::BaseHandle(arg1);
18271     } catch (std::out_of_range& e) {
18272       {
18273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18274       };
18275     } catch (std::exception& e) {
18276       {
18277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18278       };
18279     } catch (Dali::DaliException e) {
18280       {
18281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18282       };
18283     } catch (...) {
18284       {
18285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18286       };
18287     }
18288   }
18289
18290   jresult = (void *)result;
18291   return jresult;
18292 }
18293
18294
18295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_1() {
18296   void * jresult ;
18297   Dali::BaseHandle *result = 0 ;
18298
18299   {
18300     try {
18301       result = (Dali::BaseHandle *)new Dali::BaseHandle();
18302     } catch (std::out_of_range& e) {
18303       {
18304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18305       };
18306     } catch (std::exception& e) {
18307       {
18308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18309       };
18310     } catch (Dali::DaliException e) {
18311       {
18312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18313       };
18314     } catch (...) {
18315       {
18316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18317       };
18318     }
18319   }
18320
18321   jresult = (void *)result;
18322   return jresult;
18323 }
18324
18325
18326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BaseHandle(void * jarg1) {
18327   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18328
18329   arg1 = (Dali::BaseHandle *)jarg1;
18330   {
18331     try {
18332       delete arg1;
18333     } catch (std::out_of_range& e) {
18334       {
18335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18336       };
18337     } catch (std::exception& e) {
18338       {
18339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18340       };
18341     } catch (Dali::DaliException e) {
18342       {
18343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18344       };
18345     } catch (...) {
18346       {
18347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18348       };
18349     }
18350   }
18351
18352 }
18353
18354
18355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_2(void * jarg1) {
18356   void * jresult ;
18357   Dali::BaseHandle *arg1 = 0 ;
18358   Dali::BaseHandle *result = 0 ;
18359
18360   arg1 = (Dali::BaseHandle *)jarg1;
18361   if (!arg1) {
18362     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18363     return 0;
18364   }
18365   {
18366     try {
18367       result = (Dali::BaseHandle *)new Dali::BaseHandle((Dali::BaseHandle const &)*arg1);
18368     } catch (std::out_of_range& e) {
18369       {
18370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18371       };
18372     } catch (std::exception& e) {
18373       {
18374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18375       };
18376     } catch (Dali::DaliException e) {
18377       {
18378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18379       };
18380     } catch (...) {
18381       {
18382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18383       };
18384     }
18385   }
18386
18387   jresult = (void *)result;
18388   return jresult;
18389 }
18390
18391
18392 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_Assign(void * jarg1, void * jarg2) {
18393   void * jresult ;
18394   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18395   Dali::BaseHandle *arg2 = 0 ;
18396   Dali::BaseHandle *result = 0 ;
18397
18398   arg1 = (Dali::BaseHandle *)jarg1;
18399   arg2 = (Dali::BaseHandle *)jarg2;
18400   if (!arg2) {
18401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18402     return 0;
18403   }
18404   {
18405     try {
18406       result = (Dali::BaseHandle *) &(arg1)->operator =((Dali::BaseHandle const &)*arg2);
18407     } catch (std::out_of_range& e) {
18408       {
18409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18410       };
18411     } catch (std::exception& e) {
18412       {
18413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18414       };
18415     } catch (Dali::DaliException e) {
18416       {
18417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18418       };
18419     } catch (...) {
18420       {
18421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18422       };
18423     }
18424   }
18425
18426   jresult = (void *)result;
18427   return jresult;
18428 }
18429
18430
18431 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_DoAction(void * jarg1, char * jarg2, void * jarg3) {
18432   unsigned int jresult ;
18433   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18434   std::string *arg2 = 0 ;
18435   Dali::Property::Map *arg3 = 0 ;
18436   bool result;
18437
18438   arg1 = (Dali::BaseHandle *)jarg1;
18439   if (!jarg2) {
18440     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18441     return 0;
18442   }
18443   std::string arg2_str(jarg2);
18444   arg2 = &arg2_str;
18445   arg3 = (Dali::Property::Map *)jarg3;
18446   if (!arg3) {
18447     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
18448     return 0;
18449   }
18450   {
18451     try {
18452       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
18453     } catch (std::out_of_range& e) {
18454       {
18455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18456       };
18457     } catch (std::exception& e) {
18458       {
18459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18460       };
18461     } catch (Dali::DaliException e) {
18462       {
18463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18464       };
18465     } catch (...) {
18466       {
18467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18468       };
18469     }
18470   }
18471
18472   jresult = result;
18473
18474   //argout typemap for const std::string&
18475
18476   return jresult;
18477 }
18478
18479
18480 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeName(void * jarg1) {
18481   char * jresult ;
18482   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18483   std::string *result = 0 ;
18484
18485   arg1 = (Dali::BaseHandle *)jarg1;
18486   {
18487     try {
18488       result = (std::string *) &((Dali::BaseHandle const *)arg1)->GetTypeName();
18489     } catch (std::out_of_range& e) {
18490       {
18491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18492       };
18493     } catch (std::exception& e) {
18494       {
18495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18496       };
18497     } catch (Dali::DaliException e) {
18498       {
18499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18500       };
18501     } catch (...) {
18502       {
18503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18504       };
18505     }
18506   }
18507
18508   jresult = SWIG_csharp_string_callback(result->c_str());
18509   return jresult;
18510 }
18511
18512
18513 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeInfo(void * jarg1, void * jarg2) {
18514   unsigned int jresult ;
18515   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18516   Dali::TypeInfo *arg2 = 0 ;
18517   bool result;
18518
18519   arg1 = (Dali::BaseHandle *)jarg1;
18520   arg2 = (Dali::TypeInfo *)jarg2;
18521   if (!arg2) {
18522     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
18523     return 0;
18524   }
18525   {
18526     try {
18527       result = (bool)((Dali::BaseHandle const *)arg1)->GetTypeInfo(*arg2);
18528     } catch (std::out_of_range& e) {
18529       {
18530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18531       };
18532     } catch (std::exception& e) {
18533       {
18534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18535       };
18536     } catch (Dali::DaliException e) {
18537       {
18538         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18539       };
18540     } catch (...) {
18541       {
18542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18543       };
18544     }
18545   }
18546
18547   jresult = result;
18548   return jresult;
18549 }
18550
18551
18552 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetBaseObject__SWIG_0(void * jarg1) {
18553   void * jresult ;
18554   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18555   Dali::BaseObject *result = 0 ;
18556
18557   arg1 = (Dali::BaseHandle *)jarg1;
18558   {
18559     try {
18560       result = (Dali::BaseObject *) &(arg1)->GetBaseObject();
18561     } catch (std::out_of_range& e) {
18562       {
18563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18564       };
18565     } catch (std::exception& e) {
18566       {
18567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18568       };
18569     } catch (Dali::DaliException e) {
18570       {
18571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18572       };
18573     } catch (...) {
18574       {
18575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18576       };
18577     }
18578   }
18579
18580   jresult = (void *)result;
18581   return jresult;
18582 }
18583
18584
18585 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BaseHandle_Reset(void * jarg1) {
18586   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18587
18588   arg1 = (Dali::BaseHandle *)jarg1;
18589   {
18590     try {
18591       (arg1)->Reset();
18592     } catch (std::out_of_range& e) {
18593       {
18594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18595       };
18596     } catch (std::exception& e) {
18597       {
18598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18599       };
18600     } catch (Dali::DaliException e) {
18601       {
18602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18603       };
18604     } catch (...) {
18605       {
18606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18607       };
18608     }
18609   }
18610
18611 }
18612
18613
18614 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_EqualTo(void * jarg1, void * jarg2) {
18615   unsigned int jresult ;
18616   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18617   Dali::BaseHandle *arg2 = 0 ;
18618   bool result;
18619
18620   arg1 = (Dali::BaseHandle *)jarg1;
18621   arg2 = (Dali::BaseHandle *)jarg2;
18622   if (!arg2) {
18623     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18624     return 0;
18625   }
18626   {
18627     try {
18628       result = (bool)((Dali::BaseHandle const *)arg1)->operator ==((Dali::BaseHandle const &)*arg2);
18629     } catch (std::out_of_range& e) {
18630       {
18631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18632       };
18633     } catch (std::exception& e) {
18634       {
18635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18636       };
18637     } catch (Dali::DaliException e) {
18638       {
18639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18640       };
18641     } catch (...) {
18642       {
18643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18644       };
18645     }
18646   }
18647
18648   jresult = result;
18649   return jresult;
18650 }
18651
18652
18653 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_NotEqualTo(void * jarg1, void * jarg2) {
18654   unsigned int jresult ;
18655   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18656   Dali::BaseHandle *arg2 = 0 ;
18657   bool result;
18658
18659   arg1 = (Dali::BaseHandle *)jarg1;
18660   arg2 = (Dali::BaseHandle *)jarg2;
18661   if (!arg2) {
18662     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18663     return 0;
18664   }
18665   {
18666     try {
18667       result = (bool)((Dali::BaseHandle const *)arg1)->operator !=((Dali::BaseHandle const &)*arg2);
18668     } catch (std::out_of_range& e) {
18669       {
18670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18671       };
18672     } catch (std::exception& e) {
18673       {
18674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18675       };
18676     } catch (Dali::DaliException e) {
18677       {
18678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18679       };
18680     } catch (...) {
18681       {
18682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18683       };
18684     }
18685   }
18686
18687   jresult = result;
18688   return jresult;
18689 }
18690
18691
18692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetObjectPtr(void * jarg1) {
18693   void * jresult ;
18694   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18695   Dali::RefObject *result = 0 ;
18696
18697   arg1 = (Dali::BaseHandle *)jarg1;
18698   {
18699     try {
18700       result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
18701     } catch (std::out_of_range& e) {
18702       {
18703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18704       };
18705     } catch (std::exception& e) {
18706       {
18707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18708       };
18709     } catch (Dali::DaliException e) {
18710       {
18711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18712       };
18713     } catch (...) {
18714       {
18715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18716       };
18717     }
18718   }
18719
18720   jresult = (void *)result;
18721   return jresult;
18722 }
18723
18724
18725 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_HasBody(void * jarg1) {
18726   unsigned int jresult ;
18727   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18728   bool result;
18729
18730   arg1 = (Dali::BaseHandle *)jarg1;
18731   {
18732     try {
18733       result = (bool)Dali_BaseHandle_HasBody((Dali::BaseHandle const *)arg1);
18734     } catch (std::out_of_range& e) {
18735       {
18736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18737       };
18738     } catch (std::exception& e) {
18739       {
18740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18741       };
18742     } catch (Dali::DaliException e) {
18743       {
18744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18745       };
18746     } catch (...) {
18747       {
18748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18749       };
18750     }
18751   }
18752
18753   jresult = result;
18754   return jresult;
18755 }
18756
18757
18758 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_IsEqual(void * jarg1, void * jarg2) {
18759   unsigned int jresult ;
18760   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18761   Dali::BaseHandle *arg2 = 0 ;
18762   bool result;
18763
18764   arg1 = (Dali::BaseHandle *)jarg1;
18765   arg2 = (Dali::BaseHandle *)jarg2;
18766   if (!arg2) {
18767     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18768     return 0;
18769   }
18770   {
18771     try {
18772       result = (bool)Dali_BaseHandle_IsEqual((Dali::BaseHandle const *)arg1,(Dali::BaseHandle const &)*arg2);
18773     } catch (std::out_of_range& e) {
18774       {
18775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18776       };
18777     } catch (std::exception& e) {
18778       {
18779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18780       };
18781     } catch (Dali::DaliException e) {
18782       {
18783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18784       };
18785     } catch (...) {
18786       {
18787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18788       };
18789     }
18790   }
18791
18792   jresult = result;
18793   return jresult;
18794 }
18795
18796
18797 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_3(void * jarg1, void * jarg2) {
18798   unsigned int jresult ;
18799   Dali::BaseHandle *arg1 = 0 ;
18800   Dali::BaseHandle *arg2 = 0 ;
18801   bool result;
18802
18803   arg1 = (Dali::BaseHandle *)jarg1;
18804   if (!arg1) {
18805     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18806     return 0;
18807   }
18808   arg2 = (Dali::BaseHandle *)jarg2;
18809   if (!arg2) {
18810     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18811     return 0;
18812   }
18813   {
18814     try {
18815       result = (bool)Dali::operator <((Dali::BaseHandle const &)*arg1,(Dali::BaseHandle const &)*arg2);
18816     } catch (std::out_of_range& e) {
18817       {
18818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18819       };
18820     } catch (std::exception& e) {
18821       {
18822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18823       };
18824     } catch (Dali::DaliException e) {
18825       {
18826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18827       };
18828     } catch (...) {
18829       {
18830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18831       };
18832     }
18833   }
18834
18835   jresult = result;
18836   return jresult;
18837 }
18838
18839
18840 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTrackerInterface(void * jarg1) {
18841   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
18842
18843   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
18844   {
18845     try {
18846       delete arg1;
18847     } catch (std::out_of_range& e) {
18848       {
18849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18850       };
18851     } catch (std::exception& e) {
18852       {
18853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18854       };
18855     } catch (Dali::DaliException e) {
18856       {
18857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18858       };
18859     } catch (...) {
18860       {
18861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18862       };
18863     }
18864   }
18865
18866 }
18867
18868
18869 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
18870   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
18871   SlotObserver *arg2 = (SlotObserver *) 0 ;
18872   CallbackBase *arg3 = (CallbackBase *) 0 ;
18873
18874   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
18875   arg2 = (SlotObserver *)jarg2;
18876   arg3 = (CallbackBase *)jarg3;
18877   {
18878     try {
18879       (arg1)->SignalConnected(arg2,arg3);
18880     } catch (std::out_of_range& e) {
18881       {
18882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18883       };
18884     } catch (std::exception& e) {
18885       {
18886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18887       };
18888     } catch (Dali::DaliException e) {
18889       {
18890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18891       };
18892     } catch (...) {
18893       {
18894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18895       };
18896     }
18897   }
18898
18899 }
18900
18901
18902 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalObserver(void * jarg1) {
18903   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
18904
18905   arg1 = (Dali::SignalObserver *)jarg1;
18906   {
18907     try {
18908       delete arg1;
18909     } catch (std::out_of_range& e) {
18910       {
18911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18912       };
18913     } catch (std::exception& e) {
18914       {
18915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18916       };
18917     } catch (Dali::DaliException e) {
18918       {
18919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18920       };
18921     } catch (...) {
18922       {
18923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18924       };
18925     }
18926   }
18927
18928 }
18929
18930
18931 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SignalObserver_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
18932   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
18933   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
18934   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
18935
18936   arg1 = (Dali::SignalObserver *)jarg1;
18937   arg2 = (Dali::SlotObserver *)jarg2;
18938   arg3 = (Dali::CallbackBase *)jarg3;
18939   {
18940     try {
18941       (arg1)->SignalDisconnected(arg2,arg3);
18942     } catch (std::out_of_range& e) {
18943       {
18944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18945       };
18946     } catch (std::exception& e) {
18947       {
18948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18949       };
18950     } catch (Dali::DaliException e) {
18951       {
18952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18953       };
18954     } catch (...) {
18955       {
18956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18957       };
18958     }
18959   }
18960
18961 }
18962
18963
18964 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SlotObserver(void * jarg1) {
18965   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
18966
18967   arg1 = (Dali::SlotObserver *)jarg1;
18968   {
18969     try {
18970       delete arg1;
18971     } catch (std::out_of_range& e) {
18972       {
18973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18974       };
18975     } catch (std::exception& e) {
18976       {
18977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18978       };
18979     } catch (Dali::DaliException e) {
18980       {
18981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18982       };
18983     } catch (...) {
18984       {
18985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18986       };
18987     }
18988   }
18989
18990 }
18991
18992
18993 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SlotObserver_SlotDisconnected(void * jarg1, void * jarg2) {
18994   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
18995   Dali::CallbackBase *arg2 = (Dali::CallbackBase *) 0 ;
18996
18997   arg1 = (Dali::SlotObserver *)jarg1;
18998   arg2 = (Dali::CallbackBase *)jarg2;
18999   {
19000     try {
19001       (arg1)->SlotDisconnected(arg2);
19002     } catch (std::out_of_range& e) {
19003       {
19004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19005       };
19006     } catch (std::exception& e) {
19007       {
19008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19009       };
19010     } catch (Dali::DaliException e) {
19011       {
19012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19013       };
19014     } catch (...) {
19015       {
19016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19017       };
19018     }
19019   }
19020
19021 }
19022
19023
19024 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTracker(void * jarg1) {
19025   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19026
19027   arg1 = (Dali::ConnectionTracker *)jarg1;
19028   {
19029     try {
19030       delete arg1;
19031     } catch (std::out_of_range& e) {
19032       {
19033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19034       };
19035     } catch (std::exception& e) {
19036       {
19037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19038       };
19039     } catch (Dali::DaliException e) {
19040       {
19041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19042       };
19043     } catch (...) {
19044       {
19045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19046       };
19047     }
19048   }
19049
19050 }
19051
19052
19053 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_DisconnectAll(void * jarg1) {
19054   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19055
19056   arg1 = (Dali::ConnectionTracker *)jarg1;
19057   {
19058     try {
19059       (arg1)->DisconnectAll();
19060     } catch (std::out_of_range& e) {
19061       {
19062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19063       };
19064     } catch (std::exception& e) {
19065       {
19066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19067       };
19068     } catch (Dali::DaliException e) {
19069       {
19070         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19071       };
19072     } catch (...) {
19073       {
19074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19075       };
19076     }
19077   }
19078
19079 }
19080
19081
19082 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
19083   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19084   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
19085   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
19086
19087   arg1 = (Dali::ConnectionTracker *)jarg1;
19088   arg2 = (Dali::SlotObserver *)jarg2;
19089   arg3 = (Dali::CallbackBase *)jarg3;
19090   {
19091     try {
19092       (arg1)->SignalConnected(arg2,arg3);
19093     } catch (std::out_of_range& e) {
19094       {
19095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19096       };
19097     } catch (std::exception& e) {
19098       {
19099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19100       };
19101     } catch (Dali::DaliException e) {
19102       {
19103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19104       };
19105     } catch (...) {
19106       {
19107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19108       };
19109     }
19110   }
19111
19112 }
19113
19114
19115 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
19116   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19117   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
19118   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
19119
19120   arg1 = (Dali::ConnectionTracker *)jarg1;
19121   arg2 = (Dali::SlotObserver *)jarg2;
19122   arg3 = (Dali::CallbackBase *)jarg3;
19123   {
19124     try {
19125       (arg1)->SignalDisconnected(arg2,arg3);
19126     } catch (std::out_of_range& e) {
19127       {
19128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19129       };
19130     } catch (std::exception& e) {
19131       {
19132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19133       };
19134     } catch (Dali::DaliException e) {
19135       {
19136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19137       };
19138     } catch (...) {
19139       {
19140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19141       };
19142     }
19143   }
19144
19145 }
19146
19147
19148 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ConnectionTracker_GetConnectionCount(void * jarg1) {
19149   unsigned long jresult ;
19150   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19151   std::size_t result;
19152
19153   arg1 = (Dali::ConnectionTracker *)jarg1;
19154   {
19155     try {
19156       result = ((Dali::ConnectionTracker const *)arg1)->GetConnectionCount();
19157     } catch (std::out_of_range& e) {
19158       {
19159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19160       };
19161     } catch (std::exception& e) {
19162       {
19163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19164       };
19165     } catch (Dali::DaliException e) {
19166       {
19167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19168       };
19169     } catch (...) {
19170       {
19171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19172       };
19173     }
19174   }
19175
19176   jresult = (unsigned long)result;
19177   return jresult;
19178 }
19179
19180
19181 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_0() {
19182   void * jresult ;
19183   Dali::ObjectRegistry *result = 0 ;
19184
19185   {
19186     try {
19187       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry();
19188     } catch (std::out_of_range& e) {
19189       {
19190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19191       };
19192     } catch (std::exception& e) {
19193       {
19194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19195       };
19196     } catch (Dali::DaliException e) {
19197       {
19198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19199       };
19200     } catch (...) {
19201       {
19202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19203       };
19204     }
19205   }
19206
19207   jresult = (void *)result;
19208   return jresult;
19209 }
19210
19211
19212 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectRegistry(void * jarg1) {
19213   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19214
19215   arg1 = (Dali::ObjectRegistry *)jarg1;
19216   {
19217     try {
19218       delete arg1;
19219     } catch (std::out_of_range& e) {
19220       {
19221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19222       };
19223     } catch (std::exception& e) {
19224       {
19225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19226       };
19227     } catch (Dali::DaliException e) {
19228       {
19229         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19230       };
19231     } catch (...) {
19232       {
19233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19234       };
19235     }
19236   }
19237
19238 }
19239
19240
19241 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_1(void * jarg1) {
19242   void * jresult ;
19243   Dali::ObjectRegistry *arg1 = 0 ;
19244   Dali::ObjectRegistry *result = 0 ;
19245
19246   arg1 = (Dali::ObjectRegistry *)jarg1;
19247   if (!arg1) {
19248     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
19249     return 0;
19250   }
19251   {
19252     try {
19253       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry((Dali::ObjectRegistry const &)*arg1);
19254     } catch (std::out_of_range& e) {
19255       {
19256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19257       };
19258     } catch (std::exception& e) {
19259       {
19260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19261       };
19262     } catch (Dali::DaliException e) {
19263       {
19264         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19265       };
19266     } catch (...) {
19267       {
19268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19269       };
19270     }
19271   }
19272
19273   jresult = (void *)result;
19274   return jresult;
19275 }
19276
19277
19278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_Assign(void * jarg1, void * jarg2) {
19279   void * jresult ;
19280   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19281   Dali::ObjectRegistry *arg2 = 0 ;
19282   Dali::ObjectRegistry *result = 0 ;
19283
19284   arg1 = (Dali::ObjectRegistry *)jarg1;
19285   arg2 = (Dali::ObjectRegistry *)jarg2;
19286   if (!arg2) {
19287     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
19288     return 0;
19289   }
19290   {
19291     try {
19292       result = (Dali::ObjectRegistry *) &(arg1)->operator =((Dali::ObjectRegistry const &)*arg2);
19293     } catch (std::out_of_range& e) {
19294       {
19295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19296       };
19297     } catch (std::exception& e) {
19298       {
19299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19300       };
19301     } catch (Dali::DaliException e) {
19302       {
19303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19304       };
19305     } catch (...) {
19306       {
19307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19308       };
19309     }
19310   }
19311
19312   jresult = (void *)result;
19313   return jresult;
19314 }
19315
19316
19317 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectCreatedSignal(void * jarg1) {
19318   void * jresult ;
19319   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19320   Dali::ObjectRegistry::ObjectCreatedSignalType *result = 0 ;
19321
19322   arg1 = (Dali::ObjectRegistry *)jarg1;
19323   {
19324     try {
19325       result = (Dali::ObjectRegistry::ObjectCreatedSignalType *) &(arg1)->ObjectCreatedSignal();
19326     } catch (std::out_of_range& e) {
19327       {
19328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19329       };
19330     } catch (std::exception& e) {
19331       {
19332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19333       };
19334     } catch (Dali::DaliException e) {
19335       {
19336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19337       };
19338     } catch (...) {
19339       {
19340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19341       };
19342     }
19343   }
19344
19345   jresult = (void *)result;
19346   return jresult;
19347 }
19348
19349
19350 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectDestroyedSignal(void * jarg1) {
19351   void * jresult ;
19352   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19353   Dali::ObjectRegistry::ObjectDestroyedSignalType *result = 0 ;
19354
19355   arg1 = (Dali::ObjectRegistry *)jarg1;
19356   {
19357     try {
19358       result = (Dali::ObjectRegistry::ObjectDestroyedSignalType *) &(arg1)->ObjectDestroyedSignal();
19359     } catch (std::out_of_range& e) {
19360       {
19361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19362       };
19363     } catch (std::exception& e) {
19364       {
19365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19366       };
19367     } catch (Dali::DaliException e) {
19368       {
19369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19370       };
19371     } catch (...) {
19372       {
19373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19374       };
19375     }
19376   }
19377
19378   jresult = (void *)result;
19379   return jresult;
19380 }
19381
19382
19383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_0() {
19384   void * jresult ;
19385   Dali::PropertyCondition *result = 0 ;
19386
19387   {
19388     try {
19389       result = (Dali::PropertyCondition *)new Dali::PropertyCondition();
19390     } catch (std::out_of_range& e) {
19391       {
19392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19393       };
19394     } catch (std::exception& e) {
19395       {
19396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19397       };
19398     } catch (Dali::DaliException e) {
19399       {
19400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19401       };
19402     } catch (...) {
19403       {
19404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19405       };
19406     }
19407   }
19408
19409   jresult = (void *)result;
19410   return jresult;
19411 }
19412
19413
19414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyCondition(void * jarg1) {
19415   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19416
19417   arg1 = (Dali::PropertyCondition *)jarg1;
19418   {
19419     try {
19420       delete arg1;
19421     } catch (std::out_of_range& e) {
19422       {
19423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19424       };
19425     } catch (std::exception& e) {
19426       {
19427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19428       };
19429     } catch (Dali::DaliException e) {
19430       {
19431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19432       };
19433     } catch (...) {
19434       {
19435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19436       };
19437     }
19438   }
19439
19440 }
19441
19442
19443 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_1(void * jarg1) {
19444   void * jresult ;
19445   Dali::PropertyCondition *arg1 = 0 ;
19446   Dali::PropertyCondition *result = 0 ;
19447
19448   arg1 = (Dali::PropertyCondition *)jarg1;
19449   if (!arg1) {
19450     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
19451     return 0;
19452   }
19453   {
19454     try {
19455       result = (Dali::PropertyCondition *)new Dali::PropertyCondition((Dali::PropertyCondition const &)*arg1);
19456     } catch (std::out_of_range& e) {
19457       {
19458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19459       };
19460     } catch (std::exception& e) {
19461       {
19462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19463       };
19464     } catch (Dali::DaliException e) {
19465       {
19466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19467       };
19468     } catch (...) {
19469       {
19470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19471       };
19472     }
19473   }
19474
19475   jresult = (void *)result;
19476   return jresult;
19477 }
19478
19479
19480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyCondition_Assign(void * jarg1, void * jarg2) {
19481   void * jresult ;
19482   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19483   Dali::PropertyCondition *arg2 = 0 ;
19484   Dali::PropertyCondition *result = 0 ;
19485
19486   arg1 = (Dali::PropertyCondition *)jarg1;
19487   arg2 = (Dali::PropertyCondition *)jarg2;
19488   if (!arg2) {
19489     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
19490     return 0;
19491   }
19492   {
19493     try {
19494       result = (Dali::PropertyCondition *) &(arg1)->operator =((Dali::PropertyCondition const &)*arg2);
19495     } catch (std::out_of_range& e) {
19496       {
19497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19498       };
19499     } catch (std::exception& e) {
19500       {
19501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19502       };
19503     } catch (Dali::DaliException e) {
19504       {
19505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19506       };
19507     } catch (...) {
19508       {
19509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19510       };
19511     }
19512   }
19513
19514   jresult = (void *)result;
19515   return jresult;
19516 }
19517
19518
19519 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgumentCount(void * jarg1) {
19520   unsigned long jresult ;
19521   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19522   std::size_t result;
19523
19524   arg1 = (Dali::PropertyCondition *)jarg1;
19525   {
19526     try {
19527       result = ((Dali::PropertyCondition const *)arg1)->GetArgumentCount();
19528     } catch (std::out_of_range& e) {
19529       {
19530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19531       };
19532     } catch (std::exception& e) {
19533       {
19534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19535       };
19536     } catch (...) {
19537       {
19538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19539       };
19540     }
19541   }
19542   jresult = (unsigned long)result;
19543   return jresult;
19544 }
19545
19546
19547 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgument(void * jarg1, unsigned long jarg2) {
19548   float jresult ;
19549   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19550   std::size_t arg2 ;
19551   float result;
19552
19553   arg1 = (Dali::PropertyCondition *)jarg1;
19554   arg2 = (std::size_t)jarg2;
19555   {
19556     try {
19557       result = (float)((Dali::PropertyCondition const *)arg1)->GetArgument(arg2);
19558     } catch (std::out_of_range& e) {
19559       {
19560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19561       };
19562     } catch (std::exception& e) {
19563       {
19564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19565       };
19566     } catch (...) {
19567       {
19568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19569       };
19570     }
19571   }
19572   jresult = result;
19573   return jresult;
19574 }
19575
19576
19577 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LessThanCondition(float jarg1) {
19578   void * jresult ;
19579   float arg1 ;
19580   Dali::PropertyCondition result;
19581
19582   arg1 = (float)jarg1;
19583   {
19584     try {
19585       result = Dali::LessThanCondition(arg1);
19586     } catch (std::out_of_range& e) {
19587       {
19588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19589       };
19590     } catch (std::exception& e) {
19591       {
19592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19593       };
19594     } catch (Dali::DaliException e) {
19595       {
19596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19597       };
19598     } catch (...) {
19599       {
19600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19601       };
19602     }
19603   }
19604
19605   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19606   return jresult;
19607 }
19608
19609
19610 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GreaterThanCondition(float jarg1) {
19611   void * jresult ;
19612   float arg1 ;
19613   Dali::PropertyCondition result;
19614
19615   arg1 = (float)jarg1;
19616   {
19617     try {
19618       result = Dali::GreaterThanCondition(arg1);
19619     } catch (std::out_of_range& e) {
19620       {
19621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19622       };
19623     } catch (std::exception& e) {
19624       {
19625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19626       };
19627     } catch (Dali::DaliException e) {
19628       {
19629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19630       };
19631     } catch (...) {
19632       {
19633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19634       };
19635     }
19636   }
19637
19638   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19639   return jresult;
19640 }
19641
19642
19643 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InsideCondition(float jarg1, float jarg2) {
19644   void * jresult ;
19645   float arg1 ;
19646   float arg2 ;
19647   Dali::PropertyCondition result;
19648
19649   arg1 = (float)jarg1;
19650   arg2 = (float)jarg2;
19651   {
19652     try {
19653       result = Dali::InsideCondition(arg1,arg2);
19654     } catch (std::out_of_range& e) {
19655       {
19656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19657       };
19658     } catch (std::exception& e) {
19659       {
19660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19661       };
19662     } catch (Dali::DaliException e) {
19663       {
19664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19665       };
19666     } catch (...) {
19667       {
19668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19669       };
19670     }
19671   }
19672
19673   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19674   return jresult;
19675 }
19676
19677
19678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_OutsideCondition(float jarg1, float jarg2) {
19679   void * jresult ;
19680   float arg1 ;
19681   float arg2 ;
19682   Dali::PropertyCondition result;
19683
19684   arg1 = (float)jarg1;
19685   arg2 = (float)jarg2;
19686   {
19687     try {
19688       result = Dali::OutsideCondition(arg1,arg2);
19689     } catch (std::out_of_range& e) {
19690       {
19691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19692       };
19693     } catch (std::exception& e) {
19694       {
19695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19696       };
19697     } catch (Dali::DaliException e) {
19698       {
19699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19700       };
19701     } catch (...) {
19702       {
19703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19704       };
19705     }
19706   }
19707
19708   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19709   return jresult;
19710 }
19711
19712
19713 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_0(float jarg1, float jarg2) {
19714   void * jresult ;
19715   float arg1 ;
19716   float arg2 ;
19717   Dali::PropertyCondition result;
19718
19719   arg1 = (float)jarg1;
19720   arg2 = (float)jarg2;
19721   {
19722     try {
19723       result = Dali::StepCondition(arg1,arg2);
19724     } catch (std::out_of_range& e) {
19725       {
19726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19727       };
19728     } catch (std::exception& e) {
19729       {
19730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19731       };
19732     } catch (Dali::DaliException e) {
19733       {
19734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19735       };
19736     } catch (...) {
19737       {
19738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19739       };
19740     }
19741   }
19742
19743   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19744   return jresult;
19745 }
19746
19747
19748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_1(float jarg1) {
19749   void * jresult ;
19750   float arg1 ;
19751   Dali::PropertyCondition result;
19752
19753   arg1 = (float)jarg1;
19754   {
19755     try {
19756       result = Dali::StepCondition(arg1);
19757     } catch (std::out_of_range& e) {
19758       {
19759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19760       };
19761     } catch (std::exception& e) {
19762       {
19763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19764       };
19765     } catch (Dali::DaliException e) {
19766       {
19767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19768       };
19769     } catch (...) {
19770       {
19771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19772       };
19773     }
19774   }
19775
19776   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19777   return jresult;
19778 }
19779
19780
19781 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VariableStepCondition(void * jarg1) {
19782   void * jresult ;
19783   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg1 = 0 ;
19784   Dali::PropertyCondition result;
19785
19786   arg1 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg1;
19787   if (!arg1) {
19788     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
19789     return 0;
19790   }
19791   {
19792     try {
19793       result = Dali::VariableStepCondition((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg1);
19794     } catch (std::out_of_range& e) {
19795       {
19796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19797       };
19798     } catch (std::exception& e) {
19799       {
19800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19801       };
19802     } catch (Dali::DaliException e) {
19803       {
19804         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19805       };
19806     } catch (...) {
19807       {
19808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19809       };
19810     }
19811   }
19812
19813   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19814   return jresult;
19815 }
19816
19817
19818 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_0() {
19819   void * jresult ;
19820   Dali::PropertyNotification *result = 0 ;
19821
19822   {
19823     try {
19824       result = (Dali::PropertyNotification *)new Dali::PropertyNotification();
19825     } catch (std::out_of_range& e) {
19826       {
19827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19828       };
19829     } catch (std::exception& e) {
19830       {
19831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19832       };
19833     } catch (Dali::DaliException e) {
19834       {
19835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19836       };
19837     } catch (...) {
19838       {
19839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19840       };
19841     }
19842   }
19843
19844   jresult = (void *)result;
19845   return jresult;
19846 }
19847
19848
19849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_DownCast(void * jarg1) {
19850   void * jresult ;
19851   Dali::BaseHandle arg1 ;
19852   Dali::BaseHandle *argp1 ;
19853   Dali::PropertyNotification result;
19854
19855   argp1 = (Dali::BaseHandle *)jarg1;
19856   if (!argp1) {
19857     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
19858     return 0;
19859   }
19860   arg1 = *argp1;
19861   {
19862     try {
19863       result = Dali::PropertyNotification::DownCast(arg1);
19864     } catch (std::out_of_range& e) {
19865       {
19866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19867       };
19868     } catch (std::exception& e) {
19869       {
19870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19871       };
19872     } catch (Dali::DaliException e) {
19873       {
19874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19875       };
19876     } catch (...) {
19877       {
19878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19879       };
19880     }
19881   }
19882
19883   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
19884   return jresult;
19885 }
19886
19887
19888 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotification(void * jarg1) {
19889   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
19890
19891   arg1 = (Dali::PropertyNotification *)jarg1;
19892   {
19893     try {
19894       delete arg1;
19895     } catch (std::out_of_range& e) {
19896       {
19897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19898       };
19899     } catch (std::exception& e) {
19900       {
19901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19902       };
19903     } catch (Dali::DaliException e) {
19904       {
19905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19906       };
19907     } catch (...) {
19908       {
19909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19910       };
19911     }
19912   }
19913
19914 }
19915
19916
19917 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_1(void * jarg1) {
19918   void * jresult ;
19919   Dali::PropertyNotification *arg1 = 0 ;
19920   Dali::PropertyNotification *result = 0 ;
19921
19922   arg1 = (Dali::PropertyNotification *)jarg1;
19923   if (!arg1) {
19924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
19925     return 0;
19926   }
19927   {
19928     try {
19929       result = (Dali::PropertyNotification *)new Dali::PropertyNotification((Dali::PropertyNotification const &)*arg1);
19930     } catch (std::out_of_range& e) {
19931       {
19932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19933       };
19934     } catch (std::exception& e) {
19935       {
19936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19937       };
19938     } catch (Dali::DaliException e) {
19939       {
19940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19941       };
19942     } catch (...) {
19943       {
19944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19945       };
19946     }
19947   }
19948
19949   jresult = (void *)result;
19950   return jresult;
19951 }
19952
19953
19954 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_Assign(void * jarg1, void * jarg2) {
19955   void * jresult ;
19956   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
19957   Dali::PropertyNotification *arg2 = 0 ;
19958   Dali::PropertyNotification *result = 0 ;
19959
19960   arg1 = (Dali::PropertyNotification *)jarg1;
19961   arg2 = (Dali::PropertyNotification *)jarg2;
19962   if (!arg2) {
19963     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
19964     return 0;
19965   }
19966   {
19967     try {
19968       result = (Dali::PropertyNotification *) &(arg1)->operator =((Dali::PropertyNotification const &)*arg2);
19969     } catch (std::out_of_range& e) {
19970       {
19971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19972       };
19973     } catch (std::exception& e) {
19974       {
19975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19976       };
19977     } catch (Dali::DaliException e) {
19978       {
19979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19980       };
19981     } catch (...) {
19982       {
19983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19984       };
19985     }
19986   }
19987
19988   jresult = (void *)result;
19989   return jresult;
19990 }
19991
19992
19993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetCondition__SWIG_0(void * jarg1) {
19994   void * jresult ;
19995   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
19996   Dali::PropertyCondition result;
19997
19998   arg1 = (Dali::PropertyNotification *)jarg1;
19999   {
20000     try {
20001       result = (arg1)->GetCondition();
20002     } catch (std::out_of_range& e) {
20003       {
20004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20005       };
20006     } catch (std::exception& e) {
20007       {
20008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20009       };
20010     } catch (Dali::DaliException e) {
20011       {
20012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20013       };
20014     } catch (...) {
20015       {
20016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20017       };
20018     }
20019   }
20020
20021   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
20022   return jresult;
20023 }
20024
20025
20026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTarget(void * jarg1) {
20027   void * jresult ;
20028   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20029   Dali::Handle result;
20030
20031   arg1 = (Dali::PropertyNotification *)jarg1;
20032   {
20033     try {
20034       result = ((Dali::PropertyNotification const *)arg1)->GetTarget();
20035     } catch (std::out_of_range& e) {
20036       {
20037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20038       };
20039     } catch (std::exception& e) {
20040       {
20041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20042       };
20043     } catch (Dali::DaliException e) {
20044       {
20045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20046       };
20047     } catch (...) {
20048       {
20049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20050       };
20051     }
20052   }
20053
20054   jresult = new Dali::Handle((const Dali::Handle &)result);
20055   return jresult;
20056 }
20057
20058
20059 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTargetProperty(void * jarg1) {
20060   int jresult ;
20061   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20062   Dali::Property::Index result;
20063
20064   arg1 = (Dali::PropertyNotification *)jarg1;
20065   {
20066     try {
20067       result = (Dali::Property::Index)((Dali::PropertyNotification const *)arg1)->GetTargetProperty();
20068     } catch (std::out_of_range& e) {
20069       {
20070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20071       };
20072     } catch (std::exception& e) {
20073       {
20074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20075       };
20076     } catch (Dali::DaliException e) {
20077       {
20078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20079       };
20080     } catch (...) {
20081       {
20082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20083       };
20084     }
20085   }
20086
20087   jresult = result;
20088   return jresult;
20089 }
20090
20091
20092 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotification_SetNotifyMode(void * jarg1, int jarg2) {
20093   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20094   Dali::PropertyNotification::NotifyMode arg2 ;
20095
20096   arg1 = (Dali::PropertyNotification *)jarg1;
20097   arg2 = (Dali::PropertyNotification::NotifyMode)jarg2;
20098   {
20099     try {
20100       (arg1)->SetNotifyMode(arg2);
20101     } catch (std::out_of_range& e) {
20102       {
20103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20104       };
20105     } catch (std::exception& e) {
20106       {
20107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20108       };
20109     } catch (Dali::DaliException e) {
20110       {
20111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20112       };
20113     } catch (...) {
20114       {
20115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20116       };
20117     }
20118   }
20119
20120 }
20121
20122
20123 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyMode(void * jarg1) {
20124   int jresult ;
20125   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20126   Dali::PropertyNotification::NotifyMode result;
20127
20128   arg1 = (Dali::PropertyNotification *)jarg1;
20129   {
20130     try {
20131       result = (Dali::PropertyNotification::NotifyMode)(arg1)->GetNotifyMode();
20132     } catch (std::out_of_range& e) {
20133       {
20134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20135       };
20136     } catch (std::exception& e) {
20137       {
20138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20139       };
20140     } catch (Dali::DaliException e) {
20141       {
20142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20143       };
20144     } catch (...) {
20145       {
20146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20147       };
20148     }
20149   }
20150
20151   jresult = (int)result;
20152   return jresult;
20153 }
20154
20155
20156 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyResult(void * jarg1) {
20157   unsigned int jresult ;
20158   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20159   bool result;
20160
20161   arg1 = (Dali::PropertyNotification *)jarg1;
20162   {
20163     try {
20164       result = (bool)((Dali::PropertyNotification const *)arg1)->GetNotifyResult();
20165     } catch (std::out_of_range& e) {
20166       {
20167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20168       };
20169     } catch (std::exception& e) {
20170       {
20171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20172       };
20173     } catch (Dali::DaliException e) {
20174       {
20175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20176       };
20177     } catch (...) {
20178       {
20179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20180       };
20181     }
20182   }
20183
20184   jresult = result;
20185   return jresult;
20186 }
20187
20188
20189 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_NotifySignal(void * jarg1) {
20190   void * jresult ;
20191   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20192   Dali::PropertyNotifySignalType *result = 0 ;
20193
20194   arg1 = (Dali::PropertyNotification *)jarg1;
20195   {
20196     try {
20197       result = (Dali::PropertyNotifySignalType *) &(arg1)->NotifySignal();
20198     } catch (std::out_of_range& e) {
20199       {
20200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20201       };
20202     } catch (std::exception& e) {
20203       {
20204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20205       };
20206     } catch (Dali::DaliException e) {
20207       {
20208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20209       };
20210     } catch (...) {
20211       {
20212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20213       };
20214     }
20215   }
20216
20217   jresult = (void *)result;
20218   return jresult;
20219 }
20220
20221
20222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_0() {
20223   void * jresult ;
20224   Dali::Handle *result = 0 ;
20225
20226   {
20227     try {
20228       result = (Dali::Handle *)new Dali::Handle();
20229     } catch (std::out_of_range& e) {
20230       {
20231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20232       };
20233     } catch (std::exception& e) {
20234       {
20235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20236       };
20237     } catch (Dali::DaliException e) {
20238       {
20239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20240       };
20241     } catch (...) {
20242       {
20243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20244       };
20245     }
20246   }
20247
20248   jresult = (void *)result;
20249   return jresult;
20250 }
20251
20252
20253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_New() {
20254   void * jresult ;
20255   Dali::Handle result;
20256
20257   {
20258     try {
20259       result = Dali::Handle::New();
20260     } catch (std::out_of_range& e) {
20261       {
20262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20263       };
20264     } catch (std::exception& e) {
20265       {
20266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20267       };
20268     } catch (Dali::DaliException e) {
20269       {
20270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20271       };
20272     } catch (...) {
20273       {
20274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20275       };
20276     }
20277   }
20278
20279   jresult = new Dali::Handle((const Dali::Handle &)result);
20280   return jresult;
20281 }
20282
20283
20284 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Handle(void * jarg1) {
20285   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20286
20287   arg1 = (Dali::Handle *)jarg1;
20288   {
20289     try {
20290       delete arg1;
20291     } catch (std::out_of_range& e) {
20292       {
20293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20294       };
20295     } catch (std::exception& e) {
20296       {
20297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20298       };
20299     } catch (Dali::DaliException e) {
20300       {
20301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20302       };
20303     } catch (...) {
20304       {
20305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20306       };
20307     }
20308   }
20309
20310 }
20311
20312
20313 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_1(void * jarg1) {
20314   void * jresult ;
20315   Dali::Handle *arg1 = 0 ;
20316   Dali::Handle *result = 0 ;
20317
20318   arg1 = (Dali::Handle *)jarg1;
20319   if (!arg1) {
20320     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
20321     return 0;
20322   }
20323   {
20324     try {
20325       result = (Dali::Handle *)new Dali::Handle((Dali::Handle const &)*arg1);
20326     } catch (std::out_of_range& e) {
20327       {
20328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20329       };
20330     } catch (std::exception& e) {
20331       {
20332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20333       };
20334     } catch (Dali::DaliException e) {
20335       {
20336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20337       };
20338     } catch (...) {
20339       {
20340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20341       };
20342     }
20343   }
20344
20345   jresult = (void *)result;
20346   return jresult;
20347 }
20348
20349
20350 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_Assign(void * jarg1, void * jarg2) {
20351   void * jresult ;
20352   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20353   Dali::Handle *arg2 = 0 ;
20354   Dali::Handle *result = 0 ;
20355
20356   arg1 = (Dali::Handle *)jarg1;
20357   arg2 = (Dali::Handle *)jarg2;
20358   if (!arg2) {
20359     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
20360     return 0;
20361   }
20362   {
20363     try {
20364       result = (Dali::Handle *) &(arg1)->operator =((Dali::Handle const &)*arg2);
20365     } catch (std::out_of_range& e) {
20366       {
20367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20368       };
20369     } catch (std::exception& e) {
20370       {
20371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20372       };
20373     } catch (Dali::DaliException e) {
20374       {
20375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20376       };
20377     } catch (...) {
20378       {
20379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20380       };
20381     }
20382   }
20383
20384   jresult = (void *)result;
20385   return jresult;
20386 }
20387
20388
20389 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_DownCast(void * jarg1) {
20390   void * jresult ;
20391   Dali::BaseHandle arg1 ;
20392   Dali::BaseHandle *argp1 ;
20393   Dali::Handle result;
20394
20395   argp1 = (Dali::BaseHandle *)jarg1;
20396   if (!argp1) {
20397     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
20398     return 0;
20399   }
20400   arg1 = *argp1;
20401   {
20402     try {
20403       result = Dali::Handle::DownCast(arg1);
20404     } catch (std::out_of_range& e) {
20405       {
20406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20407       };
20408     } catch (std::exception& e) {
20409       {
20410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20411       };
20412     } catch (Dali::DaliException e) {
20413       {
20414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20415       };
20416     } catch (...) {
20417       {
20418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20419       };
20420     }
20421   }
20422
20423   jresult = new Dali::Handle((const Dali::Handle &)result);
20424   return jresult;
20425 }
20426
20427
20428 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_Supports(void * jarg1, int jarg2) {
20429   unsigned int jresult ;
20430   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20431   Dali::Handle::Capability arg2 ;
20432   bool result;
20433
20434   arg1 = (Dali::Handle *)jarg1;
20435   arg2 = (Dali::Handle::Capability)jarg2;
20436   {
20437     try {
20438       result = (bool)((Dali::Handle const *)arg1)->Supports(arg2);
20439     } catch (std::out_of_range& e) {
20440       {
20441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20442       };
20443     } catch (std::exception& e) {
20444       {
20445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20446       };
20447     } catch (Dali::DaliException e) {
20448       {
20449         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20450       };
20451     } catch (...) {
20452       {
20453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20454       };
20455     }
20456   }
20457
20458   jresult = result;
20459   return jresult;
20460 }
20461
20462
20463 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyCount(void * jarg1) {
20464   unsigned int jresult ;
20465   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20466   unsigned int result;
20467
20468   arg1 = (Dali::Handle *)jarg1;
20469   {
20470     try {
20471       result = (unsigned int)((Dali::Handle const *)arg1)->GetPropertyCount();
20472     } catch (std::out_of_range& e) {
20473       {
20474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20475       };
20476     } catch (std::exception& e) {
20477       {
20478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20479       };
20480     } catch (Dali::DaliException e) {
20481       {
20482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20483       };
20484     } catch (...) {
20485       {
20486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20487       };
20488     }
20489   }
20490
20491   jresult = result;
20492   return jresult;
20493 }
20494
20495
20496 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Handle_GetPropertyName(void * jarg1, int jarg2) {
20497   char * jresult ;
20498   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20499   Dali::Property::Index arg2 ;
20500   std::string result;
20501
20502   arg1 = (Dali::Handle *)jarg1;
20503   arg2 = (Dali::Property::Index)jarg2;
20504   {
20505     try {
20506       result = ((Dali::Handle const *)arg1)->GetPropertyName(arg2);
20507     } catch (std::out_of_range& e) {
20508       {
20509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20510       };
20511     } catch (std::exception& e) {
20512       {
20513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20514       };
20515     } catch (Dali::DaliException e) {
20516       {
20517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20518       };
20519     } catch (...) {
20520       {
20521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20522       };
20523     }
20524   }
20525
20526   jresult = SWIG_csharp_string_callback((&result)->c_str());
20527   return jresult;
20528 }
20529
20530
20531 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndex(void * jarg1, char * jarg2) {
20532   int jresult ;
20533   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20534   std::string *arg2 = 0 ;
20535   Dali::Property::Index result;
20536
20537   arg1 = (Dali::Handle *)jarg1;
20538   if (!jarg2) {
20539     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20540     return 0;
20541   }
20542   std::string arg2_str(jarg2);
20543   arg2 = &arg2_str;
20544   {
20545     try {
20546       result = (Dali::Property::Index)((Dali::Handle const *)arg1)->GetPropertyIndex((std::string const &)*arg2);
20547     } catch (std::out_of_range& e) {
20548       {
20549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20550       };
20551     } catch (std::exception& e) {
20552       {
20553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20554       };
20555     } catch (Dali::DaliException e) {
20556       {
20557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20558       };
20559     } catch (...) {
20560       {
20561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20562       };
20563     }
20564   }
20565
20566   jresult = result;
20567
20568   //argout typemap for const std::string&
20569
20570   return jresult;
20571 }
20572
20573
20574 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyWritable(void * jarg1, int jarg2) {
20575   unsigned int jresult ;
20576   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20577   Dali::Property::Index arg2 ;
20578   bool result;
20579
20580   arg1 = (Dali::Handle *)jarg1;
20581   arg2 = (Dali::Property::Index)jarg2;
20582   {
20583     try {
20584       result = (bool)((Dali::Handle const *)arg1)->IsPropertyWritable(arg2);
20585     } catch (std::out_of_range& e) {
20586       {
20587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20588       };
20589     } catch (std::exception& e) {
20590       {
20591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20592       };
20593     } catch (Dali::DaliException e) {
20594       {
20595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20596       };
20597     } catch (...) {
20598       {
20599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20600       };
20601     }
20602   }
20603
20604   jresult = result;
20605   return jresult;
20606 }
20607
20608
20609 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAnimatable(void * jarg1, int jarg2) {
20610   unsigned int jresult ;
20611   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20612   Dali::Property::Index arg2 ;
20613   bool result;
20614
20615   arg1 = (Dali::Handle *)jarg1;
20616   arg2 = (Dali::Property::Index)jarg2;
20617   {
20618     try {
20619       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAnimatable(arg2);
20620     } catch (std::out_of_range& e) {
20621       {
20622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20623       };
20624     } catch (std::exception& e) {
20625       {
20626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20627       };
20628     } catch (Dali::DaliException e) {
20629       {
20630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20631       };
20632     } catch (...) {
20633       {
20634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20635       };
20636     }
20637   }
20638
20639   jresult = result;
20640   return jresult;
20641 }
20642
20643
20644 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAConstraintInput(void * jarg1, int jarg2) {
20645   unsigned int jresult ;
20646   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20647   Dali::Property::Index arg2 ;
20648   bool result;
20649
20650   arg1 = (Dali::Handle *)jarg1;
20651   arg2 = (Dali::Property::Index)jarg2;
20652   {
20653     try {
20654       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAConstraintInput(arg2);
20655     } catch (std::out_of_range& e) {
20656       {
20657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20658       };
20659     } catch (std::exception& e) {
20660       {
20661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20662       };
20663     } catch (Dali::DaliException e) {
20664       {
20665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20666       };
20667     } catch (...) {
20668       {
20669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20670       };
20671     }
20672   }
20673
20674   jresult = result;
20675   return jresult;
20676 }
20677
20678
20679 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyType(void * jarg1, int jarg2) {
20680   int jresult ;
20681   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20682   Dali::Property::Index arg2 ;
20683   Dali::Property::Type result;
20684
20685   arg1 = (Dali::Handle *)jarg1;
20686   arg2 = (Dali::Property::Index)jarg2;
20687   {
20688     try {
20689       result = (Dali::Property::Type)((Dali::Handle const *)arg1)->GetPropertyType(arg2);
20690     } catch (std::out_of_range& e) {
20691       {
20692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20693       };
20694     } catch (std::exception& e) {
20695       {
20696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20697       };
20698     } catch (Dali::DaliException e) {
20699       {
20700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20701       };
20702     } catch (...) {
20703       {
20704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20705       };
20706     }
20707   }
20708
20709   jresult = (int)result;
20710   return jresult;
20711 }
20712
20713
20714 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_SetProperty(void * jarg1, int jarg2, void * jarg3) {
20715   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20716   Dali::Property::Index arg2 ;
20717   Dali::Property::Value *arg3 = 0 ;
20718
20719   arg1 = (Dali::Handle *)jarg1;
20720   arg2 = (Dali::Property::Index)jarg2;
20721   arg3 = (Dali::Property::Value *)jarg3;
20722   if (!arg3) {
20723     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20724     return ;
20725   }
20726   {
20727     try {
20728       (arg1)->SetProperty(arg2,(Dali::Property::Value const &)*arg3);
20729     } catch (std::out_of_range& e) {
20730       {
20731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20732       };
20733     } catch (std::exception& e) {
20734       {
20735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20736       };
20737     } catch (Dali::DaliException e) {
20738       {
20739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20740       };
20741     } catch (...) {
20742       {
20743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20744       };
20745     }
20746   }
20747
20748 }
20749
20750
20751 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
20752   int jresult ;
20753   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20754   std::string *arg2 = 0 ;
20755   Dali::Property::Value *arg3 = 0 ;
20756   Dali::Property::Index result;
20757
20758   arg1 = (Dali::Handle *)jarg1;
20759   if (!jarg2) {
20760     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20761     return 0;
20762   }
20763   std::string arg2_str(jarg2);
20764   arg2 = &arg2_str;
20765   arg3 = (Dali::Property::Value *)jarg3;
20766   if (!arg3) {
20767     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20768     return 0;
20769   }
20770   {
20771     try {
20772       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
20773     } catch (std::out_of_range& e) {
20774       {
20775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20776       };
20777     } catch (std::exception& e) {
20778       {
20779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20780       };
20781     } catch (Dali::DaliException e) {
20782       {
20783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20784       };
20785     } catch (...) {
20786       {
20787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20788       };
20789     }
20790   }
20791
20792   jresult = result;
20793
20794   //argout typemap for const std::string&
20795
20796   return jresult;
20797 }
20798
20799
20800 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_1(void * jarg1, char * jarg2, void * jarg3, int jarg4) {
20801   int jresult ;
20802   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20803   std::string *arg2 = 0 ;
20804   Dali::Property::Value *arg3 = 0 ;
20805   Dali::Property::AccessMode arg4 ;
20806   Dali::Property::Index result;
20807
20808   arg1 = (Dali::Handle *)jarg1;
20809   if (!jarg2) {
20810     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20811     return 0;
20812   }
20813   std::string arg2_str(jarg2);
20814   arg2 = &arg2_str;
20815   arg3 = (Dali::Property::Value *)jarg3;
20816   if (!arg3) {
20817     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20818     return 0;
20819   }
20820   arg4 = (Dali::Property::AccessMode)jarg4;
20821   {
20822     try {
20823       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3,arg4);
20824     } catch (std::out_of_range& e) {
20825       {
20826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20827       };
20828     } catch (std::exception& e) {
20829       {
20830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20831       };
20832     } catch (Dali::DaliException e) {
20833       {
20834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20835       };
20836     } catch (...) {
20837       {
20838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20839       };
20840     }
20841   }
20842
20843   jresult = result;
20844
20845   //argout typemap for const std::string&
20846
20847   return jresult;
20848 }
20849
20850
20851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_GetProperty(void * jarg1, int jarg2) {
20852   void * jresult ;
20853   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20854   Dali::Property::Index arg2 ;
20855   Dali::Property::Value result;
20856
20857   arg1 = (Dali::Handle *)jarg1;
20858   arg2 = (Dali::Property::Index)jarg2;
20859   {
20860     try {
20861       result = ((Dali::Handle const *)arg1)->GetProperty(arg2);
20862     } catch (std::out_of_range& e) {
20863       {
20864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20865       };
20866     } catch (std::exception& e) {
20867       {
20868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20869       };
20870     } catch (Dali::DaliException e) {
20871       {
20872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20873       };
20874     } catch (...) {
20875       {
20876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20877       };
20878     }
20879   }
20880
20881   jresult = new Dali::Property::Value((const Dali::Property::Value &)result);
20882   return jresult;
20883 }
20884
20885
20886 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndices(void * jarg1, void * jarg2) {
20887   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20888   Dali::Property::IndexContainer *arg2 = 0 ;
20889
20890   arg1 = (Dali::Handle *)jarg1;
20891   arg2 = (Dali::Property::IndexContainer *)jarg2;
20892   if (!arg2) {
20893     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
20894     return ;
20895   }
20896   {
20897     try {
20898       ((Dali::Handle const *)arg1)->GetPropertyIndices(*arg2);
20899     } catch (std::out_of_range& e) {
20900       {
20901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20902       };
20903     } catch (std::exception& e) {
20904       {
20905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20906       };
20907     } catch (Dali::DaliException e) {
20908       {
20909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20910       };
20911     } catch (...) {
20912       {
20913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20914       };
20915     }
20916   }
20917
20918 }
20919
20920
20921 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_0(void * jarg1, int jarg2, void * jarg3) {
20922   void * jresult ;
20923   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20924   Dali::Property::Index arg2 ;
20925   Dali::PropertyCondition *arg3 = 0 ;
20926   Dali::PropertyNotification result;
20927
20928   arg1 = (Dali::Handle *)jarg1;
20929   arg2 = (Dali::Property::Index)jarg2;
20930   arg3 = (Dali::PropertyCondition *)jarg3;
20931   if (!arg3) {
20932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
20933     return 0;
20934   }
20935   {
20936     try {
20937       result = (arg1)->AddPropertyNotification(arg2,(Dali::PropertyCondition const &)*arg3);
20938     } catch (std::out_of_range& e) {
20939       {
20940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20941       };
20942     } catch (std::exception& e) {
20943       {
20944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20945       };
20946     } catch (Dali::DaliException e) {
20947       {
20948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20949       };
20950     } catch (...) {
20951       {
20952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20953       };
20954     }
20955   }
20956
20957   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
20958   return jresult;
20959 }
20960
20961
20962 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_1(void * jarg1, int jarg2, int jarg3, void * jarg4) {
20963   void * jresult ;
20964   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20965   Dali::Property::Index arg2 ;
20966   int arg3 ;
20967   Dali::PropertyCondition *arg4 = 0 ;
20968   Dali::PropertyNotification result;
20969
20970   arg1 = (Dali::Handle *)jarg1;
20971   arg2 = (Dali::Property::Index)jarg2;
20972   arg3 = (int)jarg3;
20973   arg4 = (Dali::PropertyCondition *)jarg4;
20974   if (!arg4) {
20975     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
20976     return 0;
20977   }
20978   {
20979     try {
20980       result = (arg1)->AddPropertyNotification(arg2,arg3,(Dali::PropertyCondition const &)*arg4);
20981     } catch (std::out_of_range& e) {
20982       {
20983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20984       };
20985     } catch (std::exception& e) {
20986       {
20987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20988       };
20989     } catch (Dali::DaliException e) {
20990       {
20991         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20992       };
20993     } catch (...) {
20994       {
20995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20996       };
20997     }
20998   }
20999
21000   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
21001   return jresult;
21002 }
21003
21004
21005 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotification(void * jarg1, void * jarg2) {
21006   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21007   Dali::PropertyNotification arg2 ;
21008   Dali::PropertyNotification *argp2 ;
21009
21010   arg1 = (Dali::Handle *)jarg1;
21011   argp2 = (Dali::PropertyNotification *)jarg2;
21012   if (!argp2) {
21013     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PropertyNotification", 0);
21014     return ;
21015   }
21016   arg2 = *argp2;
21017   {
21018     try {
21019       (arg1)->RemovePropertyNotification(arg2);
21020     } catch (std::out_of_range& e) {
21021       {
21022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21023       };
21024     } catch (std::exception& e) {
21025       {
21026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21027       };
21028     } catch (Dali::DaliException e) {
21029       {
21030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21031       };
21032     } catch (...) {
21033       {
21034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21035       };
21036     }
21037   }
21038
21039 }
21040
21041
21042 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotifications(void * jarg1) {
21043   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21044
21045   arg1 = (Dali::Handle *)jarg1;
21046   {
21047     try {
21048       (arg1)->RemovePropertyNotifications();
21049     } catch (std::out_of_range& e) {
21050       {
21051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21052       };
21053     } catch (std::exception& e) {
21054       {
21055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21056       };
21057     } catch (Dali::DaliException e) {
21058       {
21059         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21060       };
21061     } catch (...) {
21062       {
21063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21064       };
21065     }
21066   }
21067
21068 }
21069
21070
21071 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_0(void * jarg1) {
21072   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21073
21074   arg1 = (Dali::Handle *)jarg1;
21075   {
21076     try {
21077       (arg1)->RemoveConstraints();
21078     } catch (std::out_of_range& e) {
21079       {
21080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21081       };
21082     } catch (std::exception& e) {
21083       {
21084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21085       };
21086     } catch (Dali::DaliException e) {
21087       {
21088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21089       };
21090     } catch (...) {
21091       {
21092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21093       };
21094     }
21095   }
21096
21097 }
21098
21099
21100 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_1(void * jarg1, unsigned int jarg2) {
21101   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21102   unsigned int arg2 ;
21103
21104   arg1 = (Dali::Handle *)jarg1;
21105   arg2 = (unsigned int)jarg2;
21106   {
21107     try {
21108       (arg1)->RemoveConstraints(arg2);
21109     } catch (std::out_of_range& e) {
21110       {
21111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21112       };
21113     } catch (std::exception& e) {
21114       {
21115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21116       };
21117     } catch (Dali::DaliException e) {
21118       {
21119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21120       };
21121     } catch (...) {
21122       {
21123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21124       };
21125     }
21126   }
21127
21128 }
21129
21130
21131 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WEIGHT_get() {
21132   int jresult ;
21133   Dali::Property::Index result;
21134
21135   result = (Dali::Property::Index)(Dali::Property::Index)Dali::WeightObject::WEIGHT;
21136   jresult = result;
21137   return jresult;
21138 }
21139
21140
21141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_New() {
21142   void * jresult ;
21143   Dali::Handle result;
21144
21145   {
21146     try {
21147       result = Dali::WeightObject::New();
21148     } catch (std::out_of_range& e) {
21149       {
21150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21151       };
21152     } catch (std::exception& e) {
21153       {
21154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21155       };
21156     } catch (Dali::DaliException e) {
21157       {
21158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21159       };
21160     } catch (...) {
21161       {
21162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21163       };
21164     }
21165   }
21166
21167   jresult = new Dali::Handle((const Dali::Handle &)result);
21168   return jresult;
21169 }
21170
21171
21172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_0() {
21173   void * jresult ;
21174   Dali::TypeInfo *result = 0 ;
21175
21176   {
21177     try {
21178       result = (Dali::TypeInfo *)new Dali::TypeInfo();
21179     } catch (std::out_of_range& e) {
21180       {
21181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21182       };
21183     } catch (std::exception& e) {
21184       {
21185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21186       };
21187     } catch (Dali::DaliException e) {
21188       {
21189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21190       };
21191     } catch (...) {
21192       {
21193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21194       };
21195     }
21196   }
21197
21198   jresult = (void *)result;
21199   return jresult;
21200 }
21201
21202
21203 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeInfo(void * jarg1) {
21204   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21205
21206   arg1 = (Dali::TypeInfo *)jarg1;
21207   {
21208     try {
21209       delete arg1;
21210     } catch (std::out_of_range& e) {
21211       {
21212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21213       };
21214     } catch (std::exception& e) {
21215       {
21216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21217       };
21218     } catch (Dali::DaliException e) {
21219       {
21220         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21221       };
21222     } catch (...) {
21223       {
21224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21225       };
21226     }
21227   }
21228
21229 }
21230
21231
21232 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_1(void * jarg1) {
21233   void * jresult ;
21234   Dali::TypeInfo *arg1 = 0 ;
21235   Dali::TypeInfo *result = 0 ;
21236
21237   arg1 = (Dali::TypeInfo *)jarg1;
21238   if (!arg1) {
21239     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
21240     return 0;
21241   }
21242   {
21243     try {
21244       result = (Dali::TypeInfo *)new Dali::TypeInfo((Dali::TypeInfo const &)*arg1);
21245     } catch (std::out_of_range& e) {
21246       {
21247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21248       };
21249     } catch (std::exception& e) {
21250       {
21251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21252       };
21253     } catch (Dali::DaliException e) {
21254       {
21255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21256       };
21257     } catch (...) {
21258       {
21259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21260       };
21261     }
21262   }
21263
21264   jresult = (void *)result;
21265   return jresult;
21266 }
21267
21268
21269 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_Assign(void * jarg1, void * jarg2) {
21270   void * jresult ;
21271   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21272   Dali::TypeInfo *arg2 = 0 ;
21273   Dali::TypeInfo *result = 0 ;
21274
21275   arg1 = (Dali::TypeInfo *)jarg1;
21276   arg2 = (Dali::TypeInfo *)jarg2;
21277   if (!arg2) {
21278     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
21279     return 0;
21280   }
21281   {
21282     try {
21283       result = (Dali::TypeInfo *) &(arg1)->operator =((Dali::TypeInfo const &)*arg2);
21284     } catch (std::out_of_range& e) {
21285       {
21286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21287       };
21288     } catch (std::exception& e) {
21289       {
21290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21291       };
21292     } catch (Dali::DaliException e) {
21293       {
21294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21295       };
21296     } catch (...) {
21297       {
21298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21299       };
21300     }
21301   }
21302
21303   jresult = (void *)result;
21304   return jresult;
21305 }
21306
21307
21308 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetName(void * jarg1) {
21309   char * jresult ;
21310   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21311   std::string *result = 0 ;
21312
21313   arg1 = (Dali::TypeInfo *)jarg1;
21314   {
21315     try {
21316       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetName();
21317     } catch (std::out_of_range& e) {
21318       {
21319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21320       };
21321     } catch (std::exception& e) {
21322       {
21323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21324       };
21325     } catch (Dali::DaliException e) {
21326       {
21327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21328       };
21329     } catch (...) {
21330       {
21331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21332       };
21333     }
21334   }
21335
21336   jresult = SWIG_csharp_string_callback(result->c_str());
21337   return jresult;
21338 }
21339
21340
21341 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetBaseName(void * jarg1) {
21342   char * jresult ;
21343   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21344   std::string *result = 0 ;
21345
21346   arg1 = (Dali::TypeInfo *)jarg1;
21347   {
21348     try {
21349       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetBaseName();
21350     } catch (std::out_of_range& e) {
21351       {
21352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21353       };
21354     } catch (std::exception& e) {
21355       {
21356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21357       };
21358     } catch (Dali::DaliException e) {
21359       {
21360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21361       };
21362     } catch (...) {
21363       {
21364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21365       };
21366     }
21367   }
21368
21369   jresult = SWIG_csharp_string_callback(result->c_str());
21370   return jresult;
21371 }
21372
21373
21374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_CreateInstance(void * jarg1) {
21375   void * jresult ;
21376   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21377   Dali::BaseHandle result;
21378
21379   arg1 = (Dali::TypeInfo *)jarg1;
21380   {
21381     try {
21382       result = ((Dali::TypeInfo const *)arg1)->CreateInstance();
21383     } catch (std::out_of_range& e) {
21384       {
21385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21386       };
21387     } catch (std::exception& e) {
21388       {
21389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21390       };
21391     } catch (Dali::DaliException e) {
21392       {
21393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21394       };
21395     } catch (...) {
21396       {
21397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21398       };
21399     }
21400   }
21401
21402   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
21403   return jresult;
21404 }
21405
21406
21407 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionCount(void * jarg1) {
21408   unsigned long jresult ;
21409   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21410   size_t result;
21411
21412   arg1 = (Dali::TypeInfo *)jarg1;
21413   {
21414     try {
21415       result = ((Dali::TypeInfo const *)arg1)->GetActionCount();
21416     } catch (std::out_of_range& e) {
21417       {
21418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21419       };
21420     } catch (std::exception& e) {
21421       {
21422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21423       };
21424     } catch (Dali::DaliException e) {
21425       {
21426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21427       };
21428     } catch (...) {
21429       {
21430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21431       };
21432     }
21433   }
21434
21435   jresult = (unsigned long)result;
21436   return jresult;
21437 }
21438
21439
21440 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionName(void * jarg1, unsigned long jarg2) {
21441   char * jresult ;
21442   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21443   size_t arg2 ;
21444   std::string result;
21445
21446   arg1 = (Dali::TypeInfo *)jarg1;
21447   arg2 = (size_t)jarg2;
21448   {
21449     try {
21450       result = (arg1)->GetActionName(arg2);
21451     } catch (std::out_of_range& e) {
21452       {
21453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21454       };
21455     } catch (std::exception& e) {
21456       {
21457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21458       };
21459     } catch (Dali::DaliException e) {
21460       {
21461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21462       };
21463     } catch (...) {
21464       {
21465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21466       };
21467     }
21468   }
21469
21470   jresult = SWIG_csharp_string_callback((&result)->c_str());
21471   return jresult;
21472 }
21473
21474
21475 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalCount(void * jarg1) {
21476   unsigned long jresult ;
21477   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21478   size_t result;
21479
21480   arg1 = (Dali::TypeInfo *)jarg1;
21481   {
21482     try {
21483       result = ((Dali::TypeInfo const *)arg1)->GetSignalCount();
21484     } catch (std::out_of_range& e) {
21485       {
21486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21487       };
21488     } catch (std::exception& e) {
21489       {
21490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21491       };
21492     } catch (Dali::DaliException e) {
21493       {
21494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21495       };
21496     } catch (...) {
21497       {
21498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21499       };
21500     }
21501   }
21502
21503   jresult = (unsigned long)result;
21504   return jresult;
21505 }
21506
21507
21508 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalName(void * jarg1, unsigned long jarg2) {
21509   char * jresult ;
21510   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21511   size_t arg2 ;
21512   std::string result;
21513
21514   arg1 = (Dali::TypeInfo *)jarg1;
21515   arg2 = (size_t)jarg2;
21516   {
21517     try {
21518       result = (arg1)->GetSignalName(arg2);
21519     } catch (std::out_of_range& e) {
21520       {
21521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21522       };
21523     } catch (std::exception& e) {
21524       {
21525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21526       };
21527     } catch (Dali::DaliException e) {
21528       {
21529         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21530       };
21531     } catch (...) {
21532       {
21533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21534       };
21535     }
21536   }
21537
21538   jresult = SWIG_csharp_string_callback((&result)->c_str());
21539   return jresult;
21540 }
21541
21542
21543 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyCount(void * jarg1) {
21544   unsigned long jresult ;
21545   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21546   size_t result;
21547
21548   arg1 = (Dali::TypeInfo *)jarg1;
21549   {
21550     try {
21551       result = ((Dali::TypeInfo const *)arg1)->GetPropertyCount();
21552     } catch (std::out_of_range& e) {
21553       {
21554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21555       };
21556     } catch (std::exception& e) {
21557       {
21558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21559       };
21560     } catch (Dali::DaliException e) {
21561       {
21562         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21563       };
21564     } catch (...) {
21565       {
21566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21567       };
21568     }
21569   }
21570
21571   jresult = (unsigned long)result;
21572   return jresult;
21573 }
21574
21575
21576 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyIndices(void * jarg1, void * jarg2) {
21577   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21578   Dali::Property::IndexContainer *arg2 = 0 ;
21579
21580   arg1 = (Dali::TypeInfo *)jarg1;
21581   arg2 = (Dali::Property::IndexContainer *)jarg2;
21582   if (!arg2) {
21583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
21584     return ;
21585   }
21586   {
21587     try {
21588       ((Dali::TypeInfo const *)arg1)->GetPropertyIndices(*arg2);
21589     } catch (std::out_of_range& e) {
21590       {
21591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21592       };
21593     } catch (std::exception& e) {
21594       {
21595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21596       };
21597     } catch (Dali::DaliException e) {
21598       {
21599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21600       };
21601     } catch (...) {
21602       {
21603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21604       };
21605     }
21606   }
21607
21608 }
21609
21610
21611 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyName(void * jarg1, int jarg2) {
21612   char * jresult ;
21613   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21614   Dali::Property::Index arg2 ;
21615   std::string *result = 0 ;
21616
21617   arg1 = (Dali::TypeInfo *)jarg1;
21618   arg2 = (Dali::Property::Index)jarg2;
21619   {
21620     try {
21621       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetPropertyName(arg2);
21622     } catch (std::out_of_range& e) {
21623       {
21624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21625       };
21626     } catch (std::exception& e) {
21627       {
21628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21629       };
21630     } catch (Dali::DaliException e) {
21631       {
21632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21633       };
21634     } catch (...) {
21635       {
21636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21637       };
21638     }
21639   }
21640
21641   jresult = SWIG_csharp_string_callback(result->c_str());
21642   return jresult;
21643 }
21644
21645
21646 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Get() {
21647   void * jresult ;
21648   Dali::TypeRegistry result;
21649
21650   {
21651     try {
21652       result = Dali::TypeRegistry::Get();
21653     } catch (std::out_of_range& e) {
21654       {
21655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21656       };
21657     } catch (std::exception& e) {
21658       {
21659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21660       };
21661     } catch (Dali::DaliException e) {
21662       {
21663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21664       };
21665     } catch (...) {
21666       {
21667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21668       };
21669     }
21670   }
21671
21672   jresult = new Dali::TypeRegistry((const Dali::TypeRegistry &)result);
21673   return jresult;
21674 }
21675
21676
21677 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_0() {
21678   void * jresult ;
21679   Dali::TypeRegistry *result = 0 ;
21680
21681   {
21682     try {
21683       result = (Dali::TypeRegistry *)new Dali::TypeRegistry();
21684     } catch (std::out_of_range& e) {
21685       {
21686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21687       };
21688     } catch (std::exception& e) {
21689       {
21690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21691       };
21692     } catch (Dali::DaliException e) {
21693       {
21694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21695       };
21696     } catch (...) {
21697       {
21698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21699       };
21700     }
21701   }
21702
21703   jresult = (void *)result;
21704   return jresult;
21705 }
21706
21707
21708 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistry(void * jarg1) {
21709   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21710
21711   arg1 = (Dali::TypeRegistry *)jarg1;
21712   {
21713     try {
21714       delete arg1;
21715     } catch (std::out_of_range& e) {
21716       {
21717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21718       };
21719     } catch (std::exception& e) {
21720       {
21721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21722       };
21723     } catch (Dali::DaliException e) {
21724       {
21725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21726       };
21727     } catch (...) {
21728       {
21729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21730       };
21731     }
21732   }
21733
21734 }
21735
21736
21737 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_1(void * jarg1) {
21738   void * jresult ;
21739   Dali::TypeRegistry *arg1 = 0 ;
21740   Dali::TypeRegistry *result = 0 ;
21741
21742   arg1 = (Dali::TypeRegistry *)jarg1;
21743   if (!arg1) {
21744     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
21745     return 0;
21746   }
21747   {
21748     try {
21749       result = (Dali::TypeRegistry *)new Dali::TypeRegistry((Dali::TypeRegistry const &)*arg1);
21750     } catch (std::out_of_range& e) {
21751       {
21752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21753       };
21754     } catch (std::exception& e) {
21755       {
21756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21757       };
21758     } catch (Dali::DaliException e) {
21759       {
21760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21761       };
21762     } catch (...) {
21763       {
21764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21765       };
21766     }
21767   }
21768
21769   jresult = (void *)result;
21770   return jresult;
21771 }
21772
21773
21774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Assign(void * jarg1, void * jarg2) {
21775   void * jresult ;
21776   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21777   Dali::TypeRegistry *arg2 = 0 ;
21778   Dali::TypeRegistry *result = 0 ;
21779
21780   arg1 = (Dali::TypeRegistry *)jarg1;
21781   arg2 = (Dali::TypeRegistry *)jarg2;
21782   if (!arg2) {
21783     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
21784     return 0;
21785   }
21786   {
21787     try {
21788       result = (Dali::TypeRegistry *) &(arg1)->operator =((Dali::TypeRegistry const &)*arg2);
21789     } catch (std::out_of_range& e) {
21790       {
21791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21792       };
21793     } catch (std::exception& e) {
21794       {
21795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21796       };
21797     } catch (Dali::DaliException e) {
21798       {
21799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21800       };
21801     } catch (...) {
21802       {
21803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21804       };
21805     }
21806   }
21807
21808   jresult = (void *)result;
21809   return jresult;
21810 }
21811
21812
21813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_0(void * jarg1, char * jarg2) {
21814   void * jresult ;
21815   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21816   std::string *arg2 = 0 ;
21817   Dali::TypeInfo result;
21818
21819   arg1 = (Dali::TypeRegistry *)jarg1;
21820   if (!jarg2) {
21821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
21822     return 0;
21823   }
21824   std::string arg2_str(jarg2);
21825   arg2 = &arg2_str;
21826   {
21827     try {
21828       result = (arg1)->GetTypeInfo((std::string const &)*arg2);
21829     } catch (std::out_of_range& e) {
21830       {
21831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21832       };
21833     } catch (std::exception& e) {
21834       {
21835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21836       };
21837     } catch (Dali::DaliException e) {
21838       {
21839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21840       };
21841     } catch (...) {
21842       {
21843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21844       };
21845     }
21846   }
21847
21848   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
21849
21850   //argout typemap for const std::string&
21851
21852   return jresult;
21853 }
21854
21855
21856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_1(void * jarg1, void * jarg2) {
21857   void * jresult ;
21858   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21859   std::type_info *arg2 = 0 ;
21860   Dali::TypeInfo result;
21861
21862   arg1 = (Dali::TypeRegistry *)jarg1;
21863   arg2 = (std::type_info *)jarg2;
21864   if (!arg2) {
21865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
21866     return 0;
21867   }
21868   {
21869     try {
21870       result = (arg1)->GetTypeInfo((std::type_info const &)*arg2);
21871     } catch (std::out_of_range& e) {
21872       {
21873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21874       };
21875     } catch (std::exception& e) {
21876       {
21877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21878       };
21879     } catch (Dali::DaliException e) {
21880       {
21881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21882       };
21883     } catch (...) {
21884       {
21885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21886       };
21887     }
21888   }
21889
21890   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
21891   return jresult;
21892 }
21893
21894
21895 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeNameCount(void * jarg1) {
21896   unsigned long jresult ;
21897   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21898   size_t result;
21899
21900   arg1 = (Dali::TypeRegistry *)jarg1;
21901   {
21902     try {
21903       result = ((Dali::TypeRegistry const *)arg1)->GetTypeNameCount();
21904     } catch (std::out_of_range& e) {
21905       {
21906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21907       };
21908     } catch (std::exception& e) {
21909       {
21910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21911       };
21912     } catch (Dali::DaliException e) {
21913       {
21914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21915       };
21916     } catch (...) {
21917       {
21918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21919       };
21920     }
21921   }
21922
21923   jresult = (unsigned long)result;
21924   return jresult;
21925 }
21926
21927
21928 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeName(void * jarg1, unsigned long jarg2) {
21929   char * jresult ;
21930   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21931   size_t arg2 ;
21932   std::string result;
21933
21934   arg1 = (Dali::TypeRegistry *)jarg1;
21935   arg2 = (size_t)jarg2;
21936   {
21937     try {
21938       result = ((Dali::TypeRegistry const *)arg1)->GetTypeName(arg2);
21939     } catch (std::out_of_range& e) {
21940       {
21941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21942       };
21943     } catch (std::exception& e) {
21944       {
21945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21946       };
21947     } catch (Dali::DaliException e) {
21948       {
21949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21950       };
21951     } catch (...) {
21952       {
21953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21954       };
21955     }
21956   }
21957
21958   jresult = SWIG_csharp_string_callback((&result)->c_str());
21959   return jresult;
21960 }
21961
21962
21963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_2(void * jarg1) {
21964   void * jresult ;
21965   Dali::Internal::TypeRegistry *arg1 = (Dali::Internal::TypeRegistry *) 0 ;
21966   Dali::TypeRegistry *result = 0 ;
21967
21968   arg1 = (Dali::Internal::TypeRegistry *)jarg1;
21969   {
21970     try {
21971       result = (Dali::TypeRegistry *)new Dali::TypeRegistry(arg1);
21972     } catch (std::out_of_range& e) {
21973       {
21974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21975       };
21976     } catch (std::exception& e) {
21977       {
21978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21979       };
21980     } catch (Dali::DaliException e) {
21981       {
21982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21983       };
21984     } catch (...) {
21985       {
21986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21987       };
21988     }
21989   }
21990
21991   jresult = (void *)result;
21992   return jresult;
21993 }
21994
21995
21996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
21997   void * jresult ;
21998   std::type_info *arg1 = 0 ;
21999   std::type_info *arg2 = 0 ;
22000   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
22001   Dali::TypeRegistration *result = 0 ;
22002
22003   arg1 = (std::type_info *)jarg1;
22004   if (!arg1) {
22005     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22006     return 0;
22007   }
22008   arg2 = (std::type_info *)jarg2;
22009   if (!arg2) {
22010     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22011     return 0;
22012   }
22013   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
22014   {
22015     try {
22016       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3);
22017     } catch (std::out_of_range& e) {
22018       {
22019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22020       };
22021     } catch (std::exception& e) {
22022       {
22023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22024       };
22025     } catch (Dali::DaliException e) {
22026       {
22027         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22028       };
22029     } catch (...) {
22030       {
22031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22032       };
22033     }
22034   }
22035
22036   jresult = (void *)result;
22037   return jresult;
22038 }
22039
22040
22041 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_1(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4) {
22042   void * jresult ;
22043   std::type_info *arg1 = 0 ;
22044   std::type_info *arg2 = 0 ;
22045   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
22046   bool arg4 ;
22047   Dali::TypeRegistration *result = 0 ;
22048
22049   arg1 = (std::type_info *)jarg1;
22050   if (!arg1) {
22051     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22052     return 0;
22053   }
22054   arg2 = (std::type_info *)jarg2;
22055   if (!arg2) {
22056     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22057     return 0;
22058   }
22059   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
22060   arg4 = jarg4 ? true : false;
22061   {
22062     try {
22063       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3,arg4);
22064     } catch (std::out_of_range& e) {
22065       {
22066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22067       };
22068     } catch (std::exception& e) {
22069       {
22070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22071       };
22072     } catch (Dali::DaliException e) {
22073       {
22074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22075       };
22076     } catch (...) {
22077       {
22078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22079       };
22080     }
22081   }
22082
22083   jresult = (void *)result;
22084   return jresult;
22085 }
22086
22087
22088 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_2(char * jarg1, void * jarg2, void * jarg3) {
22089   void * jresult ;
22090   std::string *arg1 = 0 ;
22091   std::type_info *arg2 = 0 ;
22092   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
22093   Dali::TypeRegistration *result = 0 ;
22094
22095   if (!jarg1) {
22096     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22097     return 0;
22098   }
22099   std::string arg1_str(jarg1);
22100   arg1 = &arg1_str;
22101   arg2 = (std::type_info *)jarg2;
22102   if (!arg2) {
22103     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22104     return 0;
22105   }
22106   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
22107   {
22108     try {
22109       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
22110     } catch (std::out_of_range& e) {
22111       {
22112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22113       };
22114     } catch (std::exception& e) {
22115       {
22116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22117       };
22118     } catch (Dali::DaliException e) {
22119       {
22120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22121       };
22122     } catch (...) {
22123       {
22124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22125       };
22126     }
22127   }
22128
22129   jresult = (void *)result;
22130
22131   //argout typemap for const std::string&
22132
22133   return jresult;
22134 }
22135
22136
22137 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisteredName(void * jarg1) {
22138   char * jresult ;
22139   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
22140   std::string result;
22141
22142   arg1 = (Dali::TypeRegistration *)jarg1;
22143   {
22144     try {
22145       result = ((Dali::TypeRegistration const *)arg1)->RegisteredName();
22146     } catch (std::out_of_range& e) {
22147       {
22148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22149       };
22150     } catch (std::exception& e) {
22151       {
22152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22153       };
22154     } catch (Dali::DaliException e) {
22155       {
22156         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22157       };
22158     } catch (...) {
22159       {
22160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22161       };
22162     }
22163   }
22164
22165   jresult = SWIG_csharp_string_callback((&result)->c_str());
22166   return jresult;
22167 }
22168
22169
22170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterControl(char * jarg1, void * jarg2) {
22171   std::string *arg1 = 0 ;
22172   Dali::CSharpTypeInfo::CreateFunction arg2 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
22173
22174   if (!jarg1) {
22175     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22176     return ;
22177   }
22178   std::string arg1_str(jarg1);
22179   arg1 = &arg1_str;
22180   arg2 = (Dali::CSharpTypeInfo::CreateFunction)jarg2;
22181   {
22182     try {
22183       Dali_TypeRegistration_RegisterControl((std::string const &)*arg1,arg2);
22184     } catch (std::out_of_range& e) {
22185       {
22186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22187       };
22188     } catch (std::exception& e) {
22189       {
22190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22191       };
22192     } catch (Dali::DaliException e) {
22193       {
22194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22195       };
22196     } catch (...) {
22197       {
22198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22199       };
22200     }
22201   }
22202
22203
22204   //argout typemap for const std::string&
22205
22206 }
22207
22208
22209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22210   std::string *arg1 = 0 ;
22211   std::string *arg2 = 0 ;
22212   int arg3 ;
22213   Dali::Property::Type arg4 ;
22214   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
22215   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
22216
22217   if (!jarg1) {
22218     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22219     return ;
22220   }
22221   std::string arg1_str(jarg1);
22222   arg1 = &arg1_str;
22223   if (!jarg2) {
22224     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22225     return ;
22226   }
22227   std::string arg2_str(jarg2);
22228   arg2 = &arg2_str;
22229   arg3 = (int)jarg3;
22230   arg4 = (Dali::Property::Type)jarg4;
22231   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
22232   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
22233   {
22234     try {
22235       Dali_TypeRegistration_RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22236     } catch (std::out_of_range& e) {
22237       {
22238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22239       };
22240     } catch (std::exception& e) {
22241       {
22242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22243       };
22244     } catch (Dali::DaliException e) {
22245       {
22246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22247       };
22248     } catch (...) {
22249       {
22250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22251       };
22252     }
22253   }
22254
22255
22256   //argout typemap for const std::string&
22257
22258
22259   //argout typemap for const std::string&
22260
22261 }
22262
22263
22264 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistration(void * jarg1) {
22265   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
22266
22267   arg1 = (Dali::TypeRegistration *)jarg1;
22268   {
22269     try {
22270       delete arg1;
22271     } catch (std::out_of_range& e) {
22272       {
22273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22274       };
22275     } catch (std::exception& e) {
22276       {
22277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22278       };
22279     } catch (Dali::DaliException e) {
22280       {
22281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22282       };
22283     } catch (...) {
22284       {
22285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22286       };
22287     }
22288   }
22289
22290 }
22291
22292
22293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SignalConnectorType(void * jarg1, char * jarg2, void * jarg3) {
22294   void * jresult ;
22295   Dali::TypeRegistration *arg1 = 0 ;
22296   std::string *arg2 = 0 ;
22297   Dali::TypeInfo::SignalConnectorFunction arg3 = (Dali::TypeInfo::SignalConnectorFunction) 0 ;
22298   Dali::SignalConnectorType *result = 0 ;
22299
22300   arg1 = (Dali::TypeRegistration *)jarg1;
22301   if (!arg1) {
22302     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22303     return 0;
22304   }
22305   if (!jarg2) {
22306     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22307     return 0;
22308   }
22309   std::string arg2_str(jarg2);
22310   arg2 = &arg2_str;
22311   arg3 = (Dali::TypeInfo::SignalConnectorFunction)jarg3;
22312   {
22313     try {
22314       result = (Dali::SignalConnectorType *)new Dali::SignalConnectorType(*arg1,(std::string const &)*arg2,arg3);
22315     } catch (std::out_of_range& e) {
22316       {
22317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22318       };
22319     } catch (std::exception& e) {
22320       {
22321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22322       };
22323     } catch (Dali::DaliException e) {
22324       {
22325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22326       };
22327     } catch (...) {
22328       {
22329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22330       };
22331     }
22332   }
22333
22334   jresult = (void *)result;
22335
22336   //argout typemap for const std::string&
22337
22338   return jresult;
22339 }
22340
22341
22342 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalConnectorType(void * jarg1) {
22343   Dali::SignalConnectorType *arg1 = (Dali::SignalConnectorType *) 0 ;
22344
22345   arg1 = (Dali::SignalConnectorType *)jarg1;
22346   {
22347     try {
22348       delete arg1;
22349     } catch (std::out_of_range& e) {
22350       {
22351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22352       };
22353     } catch (std::exception& e) {
22354       {
22355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22356       };
22357     } catch (Dali::DaliException e) {
22358       {
22359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22360       };
22361     } catch (...) {
22362       {
22363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22364       };
22365     }
22366   }
22367
22368 }
22369
22370
22371 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeAction(void * jarg1, char * jarg2, void * jarg3) {
22372   void * jresult ;
22373   Dali::TypeRegistration *arg1 = 0 ;
22374   std::string *arg2 = 0 ;
22375   Dali::TypeInfo::ActionFunction arg3 = (Dali::TypeInfo::ActionFunction) 0 ;
22376   Dali::TypeAction *result = 0 ;
22377
22378   arg1 = (Dali::TypeRegistration *)jarg1;
22379   if (!arg1) {
22380     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22381     return 0;
22382   }
22383   if (!jarg2) {
22384     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22385     return 0;
22386   }
22387   std::string arg2_str(jarg2);
22388   arg2 = &arg2_str;
22389   arg3 = (Dali::TypeInfo::ActionFunction)jarg3;
22390   {
22391     try {
22392       result = (Dali::TypeAction *)new Dali::TypeAction(*arg1,(std::string const &)*arg2,arg3);
22393     } catch (std::out_of_range& e) {
22394       {
22395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22396       };
22397     } catch (std::exception& e) {
22398       {
22399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22400       };
22401     } catch (Dali::DaliException e) {
22402       {
22403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22404       };
22405     } catch (...) {
22406       {
22407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22408       };
22409     }
22410   }
22411
22412   jresult = (void *)result;
22413
22414   //argout typemap for const std::string&
22415
22416   return jresult;
22417 }
22418
22419
22420 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeAction(void * jarg1) {
22421   Dali::TypeAction *arg1 = (Dali::TypeAction *) 0 ;
22422
22423   arg1 = (Dali::TypeAction *)jarg1;
22424   {
22425     try {
22426       delete arg1;
22427     } catch (std::out_of_range& e) {
22428       {
22429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22430       };
22431     } catch (std::exception& e) {
22432       {
22433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22434       };
22435     } catch (Dali::DaliException e) {
22436       {
22437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22438       };
22439     } catch (...) {
22440       {
22441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22442       };
22443     }
22444   }
22445
22446 }
22447
22448
22449 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22450   void * jresult ;
22451   Dali::TypeRegistration *arg1 = 0 ;
22452   std::string *arg2 = 0 ;
22453   Dali::Property::Index arg3 ;
22454   Dali::Property::Type arg4 ;
22455   Dali::TypeInfo::SetPropertyFunction arg5 = (Dali::TypeInfo::SetPropertyFunction) 0 ;
22456   Dali::TypeInfo::GetPropertyFunction arg6 = (Dali::TypeInfo::GetPropertyFunction) 0 ;
22457   Dali::PropertyRegistration *result = 0 ;
22458
22459   arg1 = (Dali::TypeRegistration *)jarg1;
22460   if (!arg1) {
22461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22462     return 0;
22463   }
22464   if (!jarg2) {
22465     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22466     return 0;
22467   }
22468   std::string arg2_str(jarg2);
22469   arg2 = &arg2_str;
22470   arg3 = (Dali::Property::Index)jarg3;
22471   arg4 = (Dali::Property::Type)jarg4;
22472   arg5 = (Dali::TypeInfo::SetPropertyFunction)jarg5;
22473   arg6 = (Dali::TypeInfo::GetPropertyFunction)jarg6;
22474   {
22475     try {
22476       result = (Dali::PropertyRegistration *)new Dali::PropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22477     } catch (std::out_of_range& e) {
22478       {
22479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22480       };
22481     } catch (std::exception& e) {
22482       {
22483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22484       };
22485     } catch (Dali::DaliException e) {
22486       {
22487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22488       };
22489     } catch (...) {
22490       {
22491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22492       };
22493     }
22494   }
22495
22496   jresult = (void *)result;
22497
22498   //argout typemap for const std::string&
22499
22500   return jresult;
22501 }
22502
22503
22504 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyRegistration(void * jarg1) {
22505   Dali::PropertyRegistration *arg1 = (Dali::PropertyRegistration *) 0 ;
22506
22507   arg1 = (Dali::PropertyRegistration *)jarg1;
22508   {
22509     try {
22510       delete arg1;
22511     } catch (std::out_of_range& e) {
22512       {
22513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22514       };
22515     } catch (std::exception& e) {
22516       {
22517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22518       };
22519     } catch (Dali::DaliException e) {
22520       {
22521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22522       };
22523     } catch (...) {
22524       {
22525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22526       };
22527     }
22528   }
22529
22530 }
22531
22532
22533 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_0(void * jarg1, char * jarg2, int jarg3, int jarg4) {
22534   void * jresult ;
22535   Dali::TypeRegistration *arg1 = 0 ;
22536   std::string *arg2 = 0 ;
22537   Dali::Property::Index arg3 ;
22538   Dali::Property::Type arg4 ;
22539   Dali::AnimatablePropertyRegistration *result = 0 ;
22540
22541   arg1 = (Dali::TypeRegistration *)jarg1;
22542   if (!arg1) {
22543     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22544     return 0;
22545   }
22546   if (!jarg2) {
22547     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22548     return 0;
22549   }
22550   std::string arg2_str(jarg2);
22551   arg2 = &arg2_str;
22552   arg3 = (Dali::Property::Index)jarg3;
22553   arg4 = (Dali::Property::Type)jarg4;
22554   {
22555     try {
22556       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
22557     } catch (std::out_of_range& e) {
22558       {
22559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22560       };
22561     } catch (std::exception& e) {
22562       {
22563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22564       };
22565     } catch (Dali::DaliException e) {
22566       {
22567         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22568       };
22569     } catch (...) {
22570       {
22571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22572       };
22573     }
22574   }
22575
22576   jresult = (void *)result;
22577
22578   //argout typemap for const std::string&
22579
22580   return jresult;
22581 }
22582
22583
22584 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_1(void * jarg1, char * jarg2, int jarg3, void * jarg4) {
22585   void * jresult ;
22586   Dali::TypeRegistration *arg1 = 0 ;
22587   std::string *arg2 = 0 ;
22588   Dali::Property::Index arg3 ;
22589   Dali::Property::Value *arg4 = 0 ;
22590   Dali::AnimatablePropertyRegistration *result = 0 ;
22591
22592   arg1 = (Dali::TypeRegistration *)jarg1;
22593   if (!arg1) {
22594     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22595     return 0;
22596   }
22597   if (!jarg2) {
22598     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22599     return 0;
22600   }
22601   std::string arg2_str(jarg2);
22602   arg2 = &arg2_str;
22603   arg3 = (Dali::Property::Index)jarg3;
22604   arg4 = (Dali::Property::Value *)jarg4;
22605   if (!arg4) {
22606     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
22607     return 0;
22608   }
22609   {
22610     try {
22611       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,(Dali::Property::Value const &)*arg4);
22612     } catch (std::out_of_range& e) {
22613       {
22614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22615       };
22616     } catch (std::exception& e) {
22617       {
22618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22619       };
22620     } catch (Dali::DaliException e) {
22621       {
22622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22623       };
22624     } catch (...) {
22625       {
22626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22627       };
22628     }
22629   }
22630
22631   jresult = (void *)result;
22632
22633   //argout typemap for const std::string&
22634
22635   return jresult;
22636 }
22637
22638
22639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyRegistration(void * jarg1) {
22640   Dali::AnimatablePropertyRegistration *arg1 = (Dali::AnimatablePropertyRegistration *) 0 ;
22641
22642   arg1 = (Dali::AnimatablePropertyRegistration *)jarg1;
22643   {
22644     try {
22645       delete arg1;
22646     } catch (std::out_of_range& e) {
22647       {
22648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22649       };
22650     } catch (std::exception& e) {
22651       {
22652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22653       };
22654     } catch (Dali::DaliException e) {
22655       {
22656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22657       };
22658     } catch (...) {
22659       {
22660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22661       };
22662     }
22663   }
22664
22665 }
22666
22667
22668 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyComponentRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
22669   void * jresult ;
22670   Dali::TypeRegistration *arg1 = 0 ;
22671   std::string *arg2 = 0 ;
22672   Dali::Property::Index arg3 ;
22673   Dali::Property::Index arg4 ;
22674   unsigned int arg5 ;
22675   Dali::AnimatablePropertyComponentRegistration *result = 0 ;
22676
22677   arg1 = (Dali::TypeRegistration *)jarg1;
22678   if (!arg1) {
22679     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22680     return 0;
22681   }
22682   if (!jarg2) {
22683     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22684     return 0;
22685   }
22686   std::string arg2_str(jarg2);
22687   arg2 = &arg2_str;
22688   arg3 = (Dali::Property::Index)jarg3;
22689   arg4 = (Dali::Property::Index)jarg4;
22690   arg5 = (unsigned int)jarg5;
22691   {
22692     try {
22693       result = (Dali::AnimatablePropertyComponentRegistration *)new Dali::AnimatablePropertyComponentRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5);
22694     } catch (std::out_of_range& e) {
22695       {
22696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22697       };
22698     } catch (std::exception& e) {
22699       {
22700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22701       };
22702     } catch (Dali::DaliException e) {
22703       {
22704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22705       };
22706     } catch (...) {
22707       {
22708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22709       };
22710     }
22711   }
22712
22713   jresult = (void *)result;
22714
22715   //argout typemap for const std::string&
22716
22717   return jresult;
22718 }
22719
22720
22721 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyComponentRegistration(void * jarg1) {
22722   Dali::AnimatablePropertyComponentRegistration *arg1 = (Dali::AnimatablePropertyComponentRegistration *) 0 ;
22723
22724   arg1 = (Dali::AnimatablePropertyComponentRegistration *)jarg1;
22725   {
22726     try {
22727       delete arg1;
22728     } catch (std::out_of_range& e) {
22729       {
22730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22731       };
22732     } catch (std::exception& e) {
22733       {
22734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22735       };
22736     } catch (Dali::DaliException e) {
22737       {
22738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22739       };
22740     } catch (...) {
22741       {
22742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22743       };
22744     }
22745   }
22746
22747 }
22748
22749
22750 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ChildPropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4) {
22751   void * jresult ;
22752   Dali::TypeRegistration *arg1 = 0 ;
22753   std::string *arg2 = 0 ;
22754   Dali::Property::Index arg3 ;
22755   Dali::Property::Type arg4 ;
22756   Dali::ChildPropertyRegistration *result = 0 ;
22757
22758   arg1 = (Dali::TypeRegistration *)jarg1;
22759   if (!arg1) {
22760     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22761     return 0;
22762   }
22763   if (!jarg2) {
22764     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22765     return 0;
22766   }
22767   std::string arg2_str(jarg2);
22768   arg2 = &arg2_str;
22769   arg3 = (Dali::Property::Index)jarg3;
22770   arg4 = (Dali::Property::Type)jarg4;
22771   {
22772     try {
22773       result = (Dali::ChildPropertyRegistration *)new Dali::ChildPropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
22774     } catch (std::out_of_range& e) {
22775       {
22776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22777       };
22778     } catch (std::exception& e) {
22779       {
22780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22781       };
22782     } catch (Dali::DaliException e) {
22783       {
22784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22785       };
22786     } catch (...) {
22787       {
22788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22789       };
22790     }
22791   }
22792
22793   jresult = (void *)result;
22794
22795   //argout typemap for const std::string&
22796
22797   return jresult;
22798 }
22799
22800
22801 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ChildPropertyRegistration(void * jarg1) {
22802   Dali::ChildPropertyRegistration *arg1 = (Dali::ChildPropertyRegistration *) 0 ;
22803
22804   arg1 = (Dali::ChildPropertyRegistration *)jarg1;
22805   {
22806     try {
22807       delete arg1;
22808     } catch (std::out_of_range& e) {
22809       {
22810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22811       };
22812     } catch (std::exception& e) {
22813       {
22814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22815       };
22816     } catch (Dali::DaliException e) {
22817       {
22818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22819       };
22820     } catch (...) {
22821       {
22822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22823       };
22824     }
22825   }
22826
22827 }
22828
22829
22830 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterType(char * jarg1, void * jarg2, void * jarg3) {
22831   unsigned int jresult ;
22832   std::string *arg1 = 0 ;
22833   std::type_info *arg2 = 0 ;
22834   Dali::CSharpTypeInfo::CreateFunction arg3 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
22835   bool result;
22836
22837   if (!jarg1) {
22838     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22839     return 0;
22840   }
22841   std::string arg1_str(jarg1);
22842   arg1 = &arg1_str;
22843   arg2 = (std::type_info *)jarg2;
22844   if (!arg2) {
22845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22846     return 0;
22847   }
22848   arg3 = (Dali::CSharpTypeInfo::CreateFunction)jarg3;
22849   {
22850     try {
22851       result = (bool)Dali::CSharpTypeRegistry::RegisterType((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
22852     } catch (std::out_of_range& e) {
22853       {
22854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22855       };
22856     } catch (std::exception& e) {
22857       {
22858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22859       };
22860     } catch (Dali::DaliException e) {
22861       {
22862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22863       };
22864     } catch (...) {
22865       {
22866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22867       };
22868     }
22869   }
22870
22871   jresult = result;
22872
22873   //argout typemap for const std::string&
22874
22875   return jresult;
22876 }
22877
22878
22879 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22880   unsigned int jresult ;
22881   std::string *arg1 = 0 ;
22882   std::string *arg2 = 0 ;
22883   Dali::Property::Index arg3 ;
22884   Dali::Property::Type arg4 ;
22885   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
22886   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
22887   bool result;
22888
22889   if (!jarg1) {
22890     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22891     return 0;
22892   }
22893   std::string arg1_str(jarg1);
22894   arg1 = &arg1_str;
22895   if (!jarg2) {
22896     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22897     return 0;
22898   }
22899   std::string arg2_str(jarg2);
22900   arg2 = &arg2_str;
22901   arg3 = (Dali::Property::Index)jarg3;
22902   arg4 = (Dali::Property::Type)jarg4;
22903   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
22904   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
22905   {
22906     try {
22907       result = (bool)Dali::CSharpTypeRegistry::RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22908     } catch (std::out_of_range& e) {
22909       {
22910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22911       };
22912     } catch (std::exception& e) {
22913       {
22914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22915       };
22916     } catch (Dali::DaliException e) {
22917       {
22918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22919       };
22920     } catch (...) {
22921       {
22922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22923       };
22924     }
22925   }
22926
22927   jresult = result;
22928
22929   //argout typemap for const std::string&
22930
22931
22932   //argout typemap for const std::string&
22933
22934   return jresult;
22935 }
22936
22937
22938 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginTop_get() {
22939   float jresult ;
22940   float result;
22941
22942   result = (float)(float)Dali::ParentOrigin::TOP;
22943   jresult = result;
22944   return jresult;
22945 }
22946
22947
22948 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginBottom_get() {
22949   float jresult ;
22950   float result;
22951
22952   result = (float)(float)Dali::ParentOrigin::BOTTOM;
22953   jresult = result;
22954   return jresult;
22955 }
22956
22957
22958 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginLeft_get() {
22959   float jresult ;
22960   float result;
22961
22962   result = (float)(float)Dali::ParentOrigin::LEFT;
22963   jresult = result;
22964   return jresult;
22965 }
22966
22967
22968 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginRight_get() {
22969   float jresult ;
22970   float result;
22971
22972   result = (float)(float)Dali::ParentOrigin::RIGHT;
22973   jresult = result;
22974   return jresult;
22975 }
22976
22977
22978 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginMiddle_get() {
22979   float jresult ;
22980   float result;
22981
22982   result = (float)(float)Dali::ParentOrigin::MIDDLE;
22983   jresult = result;
22984   return jresult;
22985 }
22986
22987
22988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopLeft_get() {
22989   void * jresult ;
22990   Dali::Vector3 *result = 0 ;
22991
22992   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_LEFT;
22993   jresult = (void *)result;
22994   return jresult;
22995 }
22996
22997
22998 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopCenter_get() {
22999   void * jresult ;
23000   Dali::Vector3 *result = 0 ;
23001
23002   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_CENTER;
23003   jresult = (void *)result;
23004   return jresult;
23005 }
23006
23007
23008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopRight_get() {
23009   void * jresult ;
23010   Dali::Vector3 *result = 0 ;
23011
23012   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_RIGHT;
23013   jresult = (void *)result;
23014   return jresult;
23015 }
23016
23017
23018 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterLeft_get() {
23019   void * jresult ;
23020   Dali::Vector3 *result = 0 ;
23021
23022   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_LEFT;
23023   jresult = (void *)result;
23024   return jresult;
23025 }
23026
23027
23028 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenter_get() {
23029   void * jresult ;
23030   Dali::Vector3 *result = 0 ;
23031
23032   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER;
23033   jresult = (void *)result;
23034   return jresult;
23035 }
23036
23037
23038 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterRight_get() {
23039   void * jresult ;
23040   Dali::Vector3 *result = 0 ;
23041
23042   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_RIGHT;
23043   jresult = (void *)result;
23044   return jresult;
23045 }
23046
23047
23048 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomLeft_get() {
23049   void * jresult ;
23050   Dali::Vector3 *result = 0 ;
23051
23052   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_LEFT;
23053   jresult = (void *)result;
23054   return jresult;
23055 }
23056
23057
23058 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomCenter_get() {
23059   void * jresult ;
23060   Dali::Vector3 *result = 0 ;
23061
23062   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_CENTER;
23063   jresult = (void *)result;
23064   return jresult;
23065 }
23066
23067
23068 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomRight_get() {
23069   void * jresult ;
23070   Dali::Vector3 *result = 0 ;
23071
23072   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_RIGHT;
23073   jresult = (void *)result;
23074   return jresult;
23075 }
23076
23077
23078 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointTop_get() {
23079   float jresult ;
23080   float result;
23081
23082   result = (float)(float)Dali::AnchorPoint::TOP;
23083   jresult = result;
23084   return jresult;
23085 }
23086
23087
23088 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointBottom_get() {
23089   float jresult ;
23090   float result;
23091
23092   result = (float)(float)Dali::AnchorPoint::BOTTOM;
23093   jresult = result;
23094   return jresult;
23095 }
23096
23097
23098 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointLeft_get() {
23099   float jresult ;
23100   float result;
23101
23102   result = (float)(float)Dali::AnchorPoint::LEFT;
23103   jresult = result;
23104   return jresult;
23105 }
23106
23107
23108 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointRight_get() {
23109   float jresult ;
23110   float result;
23111
23112   result = (float)(float)Dali::AnchorPoint::RIGHT;
23113   jresult = result;
23114   return jresult;
23115 }
23116
23117
23118 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointMiddle_get() {
23119   float jresult ;
23120   float result;
23121
23122   result = (float)(float)Dali::AnchorPoint::MIDDLE;
23123   jresult = result;
23124   return jresult;
23125 }
23126
23127
23128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopLeft_get() {
23129   void * jresult ;
23130   Dali::Vector3 *result = 0 ;
23131
23132   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_LEFT;
23133   jresult = (void *)result;
23134   return jresult;
23135 }
23136
23137
23138 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopCenter_get() {
23139   void * jresult ;
23140   Dali::Vector3 *result = 0 ;
23141
23142   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_CENTER;
23143   jresult = (void *)result;
23144   return jresult;
23145 }
23146
23147
23148 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopRight_get() {
23149   void * jresult ;
23150   Dali::Vector3 *result = 0 ;
23151
23152   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_RIGHT;
23153   jresult = (void *)result;
23154   return jresult;
23155 }
23156
23157
23158 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterLeft_get() {
23159   void * jresult ;
23160   Dali::Vector3 *result = 0 ;
23161
23162   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_LEFT;
23163   jresult = (void *)result;
23164   return jresult;
23165 }
23166
23167
23168 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenter_get() {
23169   void * jresult ;
23170   Dali::Vector3 *result = 0 ;
23171
23172   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER;
23173   jresult = (void *)result;
23174   return jresult;
23175 }
23176
23177
23178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterRight_get() {
23179   void * jresult ;
23180   Dali::Vector3 *result = 0 ;
23181
23182   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_RIGHT;
23183   jresult = (void *)result;
23184   return jresult;
23185 }
23186
23187
23188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomLeft_get() {
23189   void * jresult ;
23190   Dali::Vector3 *result = 0 ;
23191
23192   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_LEFT;
23193   jresult = (void *)result;
23194   return jresult;
23195 }
23196
23197
23198 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomCenter_get() {
23199   void * jresult ;
23200   Dali::Vector3 *result = 0 ;
23201
23202   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_CENTER;
23203   jresult = (void *)result;
23204   return jresult;
23205 }
23206
23207
23208 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomRight_get() {
23209   void * jresult ;
23210   Dali::Vector3 *result = 0 ;
23211
23212   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_RIGHT;
23213   jresult = (void *)result;
23214   return jresult;
23215 }
23216
23217
23218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLACK_get() {
23219   void * jresult ;
23220   Dali::Vector4 *result = 0 ;
23221
23222   result = (Dali::Vector4 *)&Dali::Color::BLACK;
23223   jresult = (void *)result;
23224   return jresult;
23225 }
23226
23227
23228 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WHITE_get() {
23229   void * jresult ;
23230   Dali::Vector4 *result = 0 ;
23231
23232   result = (Dali::Vector4 *)&Dali::Color::WHITE;
23233   jresult = (void *)result;
23234   return jresult;
23235 }
23236
23237
23238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RED_get() {
23239   void * jresult ;
23240   Dali::Vector4 *result = 0 ;
23241
23242   result = (Dali::Vector4 *)&Dali::Color::RED;
23243   jresult = (void *)result;
23244   return jresult;
23245 }
23246
23247
23248 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GREEN_get() {
23249   void * jresult ;
23250   Dali::Vector4 *result = 0 ;
23251
23252   result = (Dali::Vector4 *)&Dali::Color::GREEN;
23253   jresult = (void *)result;
23254   return jresult;
23255 }
23256
23257
23258 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLUE_get() {
23259   void * jresult ;
23260   Dali::Vector4 *result = 0 ;
23261
23262   result = (Dali::Vector4 *)&Dali::Color::BLUE;
23263   jresult = (void *)result;
23264   return jresult;
23265 }
23266
23267
23268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_YELLOW_get() {
23269   void * jresult ;
23270   Dali::Vector4 *result = 0 ;
23271
23272   result = (Dali::Vector4 *)&Dali::Color::YELLOW;
23273   jresult = (void *)result;
23274   return jresult;
23275 }
23276
23277
23278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MAGENTA_get() {
23279   void * jresult ;
23280   Dali::Vector4 *result = 0 ;
23281
23282   result = (Dali::Vector4 *)&Dali::Color::MAGENTA;
23283   jresult = (void *)result;
23284   return jresult;
23285 }
23286
23287
23288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CYAN_get() {
23289   void * jresult ;
23290   Dali::Vector4 *result = 0 ;
23291
23292   result = (Dali::Vector4 *)&Dali::Color::CYAN;
23293   jresult = (void *)result;
23294   return jresult;
23295 }
23296
23297
23298 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TRANSPARENT_get() {
23299   void * jresult ;
23300   Dali::Vector4 *result = 0 ;
23301
23302   result = (Dali::Vector4 *)&Dali::Color::TRANSPARENT;
23303   jresult = (void *)result;
23304   return jresult;
23305 }
23306
23307
23308 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_0_get() {
23309   float jresult ;
23310   float result;
23311
23312   result = (float)(float)Dali::Math::MACHINE_EPSILON_0;
23313   jresult = result;
23314   return jresult;
23315 }
23316
23317
23318 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1_get() {
23319   float jresult ;
23320   float result;
23321
23322   result = (float)(float)Dali::Math::MACHINE_EPSILON_1;
23323   jresult = result;
23324   return jresult;
23325 }
23326
23327
23328 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10_get() {
23329   float jresult ;
23330   float result;
23331
23332   result = (float)(float)Dali::Math::MACHINE_EPSILON_10;
23333   jresult = result;
23334   return jresult;
23335 }
23336
23337
23338 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_100_get() {
23339   float jresult ;
23340   float result;
23341
23342   result = (float)(float)Dali::Math::MACHINE_EPSILON_100;
23343   jresult = result;
23344   return jresult;
23345 }
23346
23347
23348 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1000_get() {
23349   float jresult ;
23350   float result;
23351
23352   result = (float)(float)Dali::Math::MACHINE_EPSILON_1000;
23353   jresult = result;
23354   return jresult;
23355 }
23356
23357
23358 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10000_get() {
23359   float jresult ;
23360   float result;
23361
23362   result = (float)(float)Dali::Math::MACHINE_EPSILON_10000;
23363   jresult = result;
23364   return jresult;
23365 }
23366
23367
23368 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_get() {
23369   float jresult ;
23370   float result;
23371
23372   result = (float)(float)Dali::Math::PI;
23373   jresult = result;
23374   return jresult;
23375 }
23376
23377
23378 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_2_get() {
23379   float jresult ;
23380   float result;
23381
23382   result = (float)(float)Dali::Math::PI_2;
23383   jresult = result;
23384   return jresult;
23385 }
23386
23387
23388 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_4_get() {
23389   float jresult ;
23390   float result;
23391
23392   result = (float)(float)Dali::Math::PI_4;
23393   jresult = result;
23394   return jresult;
23395 }
23396
23397
23398 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_OVER_180_get() {
23399   float jresult ;
23400   float result;
23401
23402   result = (float)(float)Dali::Math::PI_OVER_180;
23403   jresult = result;
23404   return jresult;
23405 }
23406
23407
23408 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ONE80_OVER_PI_get() {
23409   float jresult ;
23410   float result;
23411
23412   result = (float)(float)Dali::Math::ONE80_OVER_PI;
23413   jresult = result;
23414   return jresult;
23415 }
23416
23417
23418 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResizePolicyDefault_get() {
23419   int jresult ;
23420   Dali::ResizePolicy::Type result;
23421
23422   result = (Dali::ResizePolicy::Type)(Dali::ResizePolicy::Type)Dali::ResizePolicy::DEFAULT;
23423   jresult = (int)result;
23424   return jresult;
23425 }
23426
23427
23428 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Count(void * jarg1) {
23429   unsigned long jresult ;
23430   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23431   Dali::VectorBase::SizeType result;
23432
23433   arg1 = (Dali::VectorBase *)jarg1;
23434   {
23435     try {
23436       result = ((Dali::VectorBase const *)arg1)->Count();
23437     } catch (std::out_of_range& e) {
23438       {
23439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23440       };
23441     } catch (std::exception& e) {
23442       {
23443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23444       };
23445     } catch (Dali::DaliException e) {
23446       {
23447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23448       };
23449     } catch (...) {
23450       {
23451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23452       };
23453     }
23454   }
23455
23456   jresult = (unsigned long)result;
23457   return jresult;
23458 }
23459
23460
23461 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Size(void * jarg1) {
23462   unsigned long jresult ;
23463   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23464   Dali::VectorBase::SizeType result;
23465
23466   arg1 = (Dali::VectorBase *)jarg1;
23467   {
23468     try {
23469       result = ((Dali::VectorBase const *)arg1)->Size();
23470     } catch (std::out_of_range& e) {
23471       {
23472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23473       };
23474     } catch (std::exception& e) {
23475       {
23476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23477       };
23478     } catch (Dali::DaliException e) {
23479       {
23480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23481       };
23482     } catch (...) {
23483       {
23484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23485       };
23486     }
23487   }
23488
23489   jresult = (unsigned long)result;
23490   return jresult;
23491 }
23492
23493
23494 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VectorBase_Empty(void * jarg1) {
23495   unsigned int jresult ;
23496   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23497   bool result;
23498
23499   arg1 = (Dali::VectorBase *)jarg1;
23500   {
23501     try {
23502       result = (bool)((Dali::VectorBase const *)arg1)->Empty();
23503     } catch (std::out_of_range& e) {
23504       {
23505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23506       };
23507     } catch (std::exception& e) {
23508       {
23509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23510       };
23511     } catch (Dali::DaliException e) {
23512       {
23513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23514       };
23515     } catch (...) {
23516       {
23517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23518       };
23519     }
23520   }
23521
23522   jresult = result;
23523   return jresult;
23524 }
23525
23526
23527 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Capacity(void * jarg1) {
23528   unsigned long jresult ;
23529   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23530   Dali::VectorBase::SizeType result;
23531
23532   arg1 = (Dali::VectorBase *)jarg1;
23533   {
23534     try {
23535       result = ((Dali::VectorBase const *)arg1)->Capacity();
23536     } catch (std::out_of_range& e) {
23537       {
23538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23539       };
23540     } catch (std::exception& e) {
23541       {
23542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23543       };
23544     } catch (Dali::DaliException e) {
23545       {
23546         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23547       };
23548     } catch (...) {
23549       {
23550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23551       };
23552     }
23553   }
23554
23555   jresult = (unsigned long)result;
23556   return jresult;
23557 }
23558
23559
23560 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorBase_Release(void * jarg1) {
23561   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23562
23563   arg1 = (Dali::VectorBase *)jarg1;
23564   {
23565     try {
23566       (arg1)->Release();
23567     } catch (std::out_of_range& e) {
23568       {
23569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23570       };
23571     } catch (std::exception& e) {
23572       {
23573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23574       };
23575     } catch (Dali::DaliException e) {
23576       {
23577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23578       };
23579     } catch (...) {
23580       {
23581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23582       };
23583     }
23584   }
23585
23586 }
23587
23588
23589 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Image__SWIG_0() {
23590   void * jresult ;
23591   Dali::Image *result = 0 ;
23592
23593   {
23594     try {
23595       result = (Dali::Image *)new Dali::Image();
23596     } catch (std::out_of_range& e) {
23597       {
23598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23599       };
23600     } catch (std::exception& e) {
23601       {
23602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23603       };
23604     } catch (Dali::DaliException e) {
23605       {
23606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23607       };
23608     } catch (...) {
23609       {
23610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23611       };
23612     }
23613   }
23614
23615   jresult = (void *)result;
23616   return jresult;
23617 }
23618
23619
23620 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Image(void * jarg1) {
23621   Dali::Image *arg1 = (Dali::Image *) 0 ;
23622
23623   arg1 = (Dali::Image *)jarg1;
23624   {
23625     try {
23626       delete arg1;
23627     } catch (std::out_of_range& e) {
23628       {
23629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23630       };
23631     } catch (std::exception& e) {
23632       {
23633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23634       };
23635     } catch (Dali::DaliException e) {
23636       {
23637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23638       };
23639     } catch (...) {
23640       {
23641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23642       };
23643     }
23644   }
23645
23646 }
23647
23648
23649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Image__SWIG_1(void * jarg1) {
23650   void * jresult ;
23651   Dali::Image *arg1 = 0 ;
23652   Dali::Image *result = 0 ;
23653
23654   arg1 = (Dali::Image *)jarg1;
23655   if (!arg1) {
23656     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
23657     return 0;
23658   }
23659   {
23660     try {
23661       result = (Dali::Image *)new Dali::Image((Dali::Image const &)*arg1);
23662     } catch (std::out_of_range& e) {
23663       {
23664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23665       };
23666     } catch (std::exception& e) {
23667       {
23668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23669       };
23670     } catch (Dali::DaliException e) {
23671       {
23672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23673       };
23674     } catch (...) {
23675       {
23676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23677       };
23678     }
23679   }
23680
23681   jresult = (void *)result;
23682   return jresult;
23683 }
23684
23685
23686 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_Assign(void * jarg1, void * jarg2) {
23687   void * jresult ;
23688   Dali::Image *arg1 = (Dali::Image *) 0 ;
23689   Dali::Image *arg2 = 0 ;
23690   Dali::Image *result = 0 ;
23691
23692   arg1 = (Dali::Image *)jarg1;
23693   arg2 = (Dali::Image *)jarg2;
23694   if (!arg2) {
23695     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
23696     return 0;
23697   }
23698   {
23699     try {
23700       result = (Dali::Image *) &(arg1)->operator =((Dali::Image const &)*arg2);
23701     } catch (std::out_of_range& e) {
23702       {
23703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23704       };
23705     } catch (std::exception& e) {
23706       {
23707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23708       };
23709     } catch (Dali::DaliException e) {
23710       {
23711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23712       };
23713     } catch (...) {
23714       {
23715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23716       };
23717     }
23718   }
23719
23720   jresult = (void *)result;
23721   return jresult;
23722 }
23723
23724
23725 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_DownCast(void * jarg1) {
23726   void * jresult ;
23727   Dali::BaseHandle arg1 ;
23728   Dali::BaseHandle *argp1 ;
23729   Dali::Image result;
23730
23731   argp1 = (Dali::BaseHandle *)jarg1;
23732   if (!argp1) {
23733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
23734     return 0;
23735   }
23736   arg1 = *argp1;
23737   {
23738     try {
23739       result = Dali::Image::DownCast(arg1);
23740     } catch (std::out_of_range& e) {
23741       {
23742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23743       };
23744     } catch (std::exception& e) {
23745       {
23746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23747       };
23748     } catch (Dali::DaliException e) {
23749       {
23750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23751       };
23752     } catch (...) {
23753       {
23754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23755       };
23756     }
23757   }
23758
23759   jresult = new Dali::Image((const Dali::Image &)result);
23760   return jresult;
23761 }
23762
23763
23764 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Image_GetWidth(void * jarg1) {
23765   unsigned int jresult ;
23766   Dali::Image *arg1 = (Dali::Image *) 0 ;
23767   unsigned int result;
23768
23769   arg1 = (Dali::Image *)jarg1;
23770   {
23771     try {
23772       result = (unsigned int)((Dali::Image const *)arg1)->GetWidth();
23773     } catch (std::out_of_range& e) {
23774       {
23775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23776       };
23777     } catch (std::exception& e) {
23778       {
23779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23780       };
23781     } catch (Dali::DaliException e) {
23782       {
23783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23784       };
23785     } catch (...) {
23786       {
23787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23788       };
23789     }
23790   }
23791
23792   jresult = result;
23793   return jresult;
23794 }
23795
23796
23797 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Image_GetHeight(void * jarg1) {
23798   unsigned int jresult ;
23799   Dali::Image *arg1 = (Dali::Image *) 0 ;
23800   unsigned int result;
23801
23802   arg1 = (Dali::Image *)jarg1;
23803   {
23804     try {
23805       result = (unsigned int)((Dali::Image const *)arg1)->GetHeight();
23806     } catch (std::out_of_range& e) {
23807       {
23808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23809       };
23810     } catch (std::exception& e) {
23811       {
23812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23813       };
23814     } catch (Dali::DaliException e) {
23815       {
23816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23817       };
23818     } catch (...) {
23819       {
23820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23821       };
23822     }
23823   }
23824
23825   jresult = result;
23826   return jresult;
23827 }
23828
23829
23830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_UploadedSignal(void * jarg1) {
23831   void * jresult ;
23832   Dali::Image *arg1 = (Dali::Image *) 0 ;
23833   Dali::Image::ImageSignalType *result = 0 ;
23834
23835   arg1 = (Dali::Image *)jarg1;
23836   {
23837     try {
23838       result = (Dali::Image::ImageSignalType *) &(arg1)->UploadedSignal();
23839     } catch (std::out_of_range& e) {
23840       {
23841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23842       };
23843     } catch (std::exception& e) {
23844       {
23845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23846       };
23847     } catch (Dali::DaliException e) {
23848       {
23849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23850       };
23851     } catch (...) {
23852       {
23853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23854       };
23855     }
23856   }
23857
23858   jresult = (void *)result;
23859   return jresult;
23860 }
23861
23862
23863 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FIRST_VALID_PIXEL_FORMAT_get() {
23864   int jresult ;
23865   Dali::Pixel::Format result;
23866
23867   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::FIRST_VALID_PIXEL_FORMAT;
23868   jresult = (int)result;
23869   return jresult;
23870 }
23871
23872
23873 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LAST_VALID_PIXEL_FORMAT_get() {
23874   int jresult ;
23875   Dali::Pixel::Format result;
23876
23877   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::LAST_VALID_PIXEL_FORMAT;
23878   jresult = (int)result;
23879   return jresult;
23880 }
23881
23882
23883 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_HasAlpha(int jarg1) {
23884   unsigned int jresult ;
23885   Dali::Pixel::Format arg1 ;
23886   bool result;
23887
23888   arg1 = (Dali::Pixel::Format)jarg1;
23889   {
23890     try {
23891       result = (bool)Dali::Pixel::HasAlpha(arg1);
23892     } catch (std::out_of_range& e) {
23893       {
23894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23895       };
23896     } catch (std::exception& e) {
23897       {
23898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23899       };
23900     } catch (Dali::DaliException e) {
23901       {
23902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23903       };
23904     } catch (...) {
23905       {
23906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23907       };
23908     }
23909   }
23910
23911   jresult = result;
23912   return jresult;
23913 }
23914
23915
23916 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetBytesPerPixel(int jarg1) {
23917   unsigned int jresult ;
23918   Dali::Pixel::Format arg1 ;
23919   unsigned int result;
23920
23921   arg1 = (Dali::Pixel::Format)jarg1;
23922   {
23923     try {
23924       result = (unsigned int)Dali::Pixel::GetBytesPerPixel(arg1);
23925     } catch (std::out_of_range& e) {
23926       {
23927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23928       };
23929     } catch (std::exception& e) {
23930       {
23931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23932       };
23933     } catch (Dali::DaliException e) {
23934       {
23935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23936       };
23937     } catch (...) {
23938       {
23939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23940       };
23941     }
23942   }
23943
23944   jresult = result;
23945   return jresult;
23946 }
23947
23948
23949 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GetAlphaOffsetAndMask(int jarg1, void * jarg2, void * jarg3) {
23950   Dali::Pixel::Format arg1 ;
23951   int *arg2 = 0 ;
23952   int *arg3 = 0 ;
23953
23954   arg1 = (Dali::Pixel::Format)jarg1;
23955   arg2 = (int *)jarg2;
23956   if (!arg2) {
23957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
23958     return ;
23959   }
23960   arg3 = (int *)jarg3;
23961   if (!arg3) {
23962     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
23963     return ;
23964   }
23965   {
23966     try {
23967       Dali::Pixel::GetAlphaOffsetAndMask(arg1,*arg2,*arg3);
23968     } catch (std::out_of_range& e) {
23969       {
23970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23971       };
23972     } catch (std::exception& e) {
23973       {
23974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23975       };
23976     } catch (Dali::DaliException e) {
23977       {
23978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23979       };
23980     } catch (...) {
23981       {
23982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23983       };
23984     }
23985   }
23986
23987 }
23988
23989
23990 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_New(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4, int jarg5, int jarg6) {
23991   void * jresult ;
23992   unsigned char *arg1 = (unsigned char *) 0 ;
23993   unsigned int arg2 ;
23994   unsigned int arg3 ;
23995   unsigned int arg4 ;
23996   Dali::Pixel::Format arg5 ;
23997   Dali::PixelData::ReleaseFunction arg6 ;
23998   Dali::PixelData result;
23999
24000   arg1 = jarg1;
24001   arg2 = (unsigned int)jarg2;
24002   arg3 = (unsigned int)jarg3;
24003   arg4 = (unsigned int)jarg4;
24004   arg5 = (Dali::Pixel::Format)jarg5;
24005   arg6 = (Dali::PixelData::ReleaseFunction)jarg6;
24006   {
24007     try {
24008       result = Dali::PixelData::New(arg1,arg2,arg3,arg4,arg5,arg6);
24009     } catch (std::out_of_range& e) {
24010       {
24011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24012       };
24013     } catch (std::exception& e) {
24014       {
24015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24016       };
24017     } catch (Dali::DaliException e) {
24018       {
24019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24020       };
24021     } catch (...) {
24022       {
24023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24024       };
24025     }
24026   }
24027
24028   jresult = new Dali::PixelData((const Dali::PixelData &)result);
24029
24030
24031   return jresult;
24032 }
24033
24034
24035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_0() {
24036   void * jresult ;
24037   Dali::PixelData *result = 0 ;
24038
24039   {
24040     try {
24041       result = (Dali::PixelData *)new Dali::PixelData();
24042     } catch (std::out_of_range& e) {
24043       {
24044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24045       };
24046     } catch (std::exception& e) {
24047       {
24048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24049       };
24050     } catch (Dali::DaliException e) {
24051       {
24052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24053       };
24054     } catch (...) {
24055       {
24056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24057       };
24058     }
24059   }
24060
24061   jresult = (void *)result;
24062   return jresult;
24063 }
24064
24065
24066 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelData(void * jarg1) {
24067   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24068
24069   arg1 = (Dali::PixelData *)jarg1;
24070   {
24071     try {
24072       delete arg1;
24073     } catch (std::out_of_range& e) {
24074       {
24075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24076       };
24077     } catch (std::exception& e) {
24078       {
24079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24080       };
24081     } catch (Dali::DaliException e) {
24082       {
24083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24084       };
24085     } catch (...) {
24086       {
24087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24088       };
24089     }
24090   }
24091
24092 }
24093
24094
24095 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_1(void * jarg1) {
24096   void * jresult ;
24097   Dali::PixelData *arg1 = 0 ;
24098   Dali::PixelData *result = 0 ;
24099
24100   arg1 = (Dali::PixelData *)jarg1;
24101   if (!arg1) {
24102     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
24103     return 0;
24104   }
24105   {
24106     try {
24107       result = (Dali::PixelData *)new Dali::PixelData((Dali::PixelData const &)*arg1);
24108     } catch (std::out_of_range& e) {
24109       {
24110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24111       };
24112     } catch (std::exception& e) {
24113       {
24114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24115       };
24116     } catch (Dali::DaliException e) {
24117       {
24118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24119       };
24120     } catch (...) {
24121       {
24122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24123       };
24124     }
24125   }
24126
24127   jresult = (void *)result;
24128   return jresult;
24129 }
24130
24131
24132 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_Assign(void * jarg1, void * jarg2) {
24133   void * jresult ;
24134   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24135   Dali::PixelData *arg2 = 0 ;
24136   Dali::PixelData *result = 0 ;
24137
24138   arg1 = (Dali::PixelData *)jarg1;
24139   arg2 = (Dali::PixelData *)jarg2;
24140   if (!arg2) {
24141     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
24142     return 0;
24143   }
24144   {
24145     try {
24146       result = (Dali::PixelData *) &(arg1)->operator =((Dali::PixelData const &)*arg2);
24147     } catch (std::out_of_range& e) {
24148       {
24149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24150       };
24151     } catch (std::exception& e) {
24152       {
24153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24154       };
24155     } catch (Dali::DaliException e) {
24156       {
24157         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24158       };
24159     } catch (...) {
24160       {
24161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24162       };
24163     }
24164   }
24165
24166   jresult = (void *)result;
24167   return jresult;
24168 }
24169
24170
24171 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetWidth(void * jarg1) {
24172   unsigned int jresult ;
24173   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24174   unsigned int result;
24175
24176   arg1 = (Dali::PixelData *)jarg1;
24177   {
24178     try {
24179       result = (unsigned int)((Dali::PixelData const *)arg1)->GetWidth();
24180     } catch (std::out_of_range& e) {
24181       {
24182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24183       };
24184     } catch (std::exception& e) {
24185       {
24186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24187       };
24188     } catch (Dali::DaliException e) {
24189       {
24190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24191       };
24192     } catch (...) {
24193       {
24194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24195       };
24196     }
24197   }
24198
24199   jresult = result;
24200   return jresult;
24201 }
24202
24203
24204 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetHeight(void * jarg1) {
24205   unsigned int jresult ;
24206   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24207   unsigned int result;
24208
24209   arg1 = (Dali::PixelData *)jarg1;
24210   {
24211     try {
24212       result = (unsigned int)((Dali::PixelData const *)arg1)->GetHeight();
24213     } catch (std::out_of_range& e) {
24214       {
24215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24216       };
24217     } catch (std::exception& e) {
24218       {
24219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24220       };
24221     } catch (Dali::DaliException e) {
24222       {
24223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24224       };
24225     } catch (...) {
24226       {
24227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24228       };
24229     }
24230   }
24231
24232   jresult = result;
24233   return jresult;
24234 }
24235
24236
24237 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelData_GetPixelFormat(void * jarg1) {
24238   int jresult ;
24239   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24240   Dali::Pixel::Format result;
24241
24242   arg1 = (Dali::PixelData *)jarg1;
24243   {
24244     try {
24245       result = (Dali::Pixel::Format)((Dali::PixelData const *)arg1)->GetPixelFormat();
24246     } catch (std::out_of_range& e) {
24247       {
24248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24249       };
24250     } catch (std::exception& e) {
24251       {
24252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24253       };
24254     } catch (Dali::DaliException e) {
24255       {
24256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24257       };
24258     } catch (...) {
24259       {
24260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24261       };
24262     }
24263   }
24264
24265   jresult = (int)result;
24266   return jresult;
24267 }
24268
24269
24270 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_X_get() {
24271   unsigned int jresult ;
24272   unsigned int result;
24273
24274   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_X;
24275   jresult = result;
24276   return jresult;
24277 }
24278
24279
24280 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_X_get() {
24281   unsigned int jresult ;
24282   unsigned int result;
24283
24284   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_X;
24285   jresult = result;
24286   return jresult;
24287 }
24288
24289
24290 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Y_get() {
24291   unsigned int jresult ;
24292   unsigned int result;
24293
24294   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Y;
24295   jresult = result;
24296   return jresult;
24297 }
24298
24299
24300 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Y_get() {
24301   unsigned int jresult ;
24302   unsigned int result;
24303
24304   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Y;
24305   jresult = result;
24306   return jresult;
24307 }
24308
24309
24310 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Z_get() {
24311   unsigned int jresult ;
24312   unsigned int result;
24313
24314   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Z;
24315   jresult = result;
24316   return jresult;
24317 }
24318
24319
24320 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Z_get() {
24321   unsigned int jresult ;
24322   unsigned int result;
24323
24324   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Z;
24325   jresult = result;
24326   return jresult;
24327 }
24328
24329
24330 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_0(int jarg1, int jarg2, unsigned int jarg3, unsigned int jarg4) {
24331   void * jresult ;
24332   Dali::TextureType::Type arg1 ;
24333   Dali::Pixel::Format arg2 ;
24334   unsigned int arg3 ;
24335   unsigned int arg4 ;
24336   Dali::Texture result;
24337
24338   arg1 = (Dali::TextureType::Type)jarg1;
24339   arg2 = (Dali::Pixel::Format)jarg2;
24340   arg3 = (unsigned int)jarg3;
24341   arg4 = (unsigned int)jarg4;
24342   {
24343     try {
24344       result = Dali::Texture::New(arg1,arg2,arg3,arg4);
24345     } catch (std::out_of_range& e) {
24346       {
24347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24348       };
24349     } catch (std::exception& e) {
24350       {
24351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24352       };
24353     } catch (Dali::DaliException e) {
24354       {
24355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24356       };
24357     } catch (...) {
24358       {
24359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24360       };
24361     }
24362   }
24363
24364   jresult = new Dali::Texture((const Dali::Texture &)result);
24365   return jresult;
24366 }
24367
24368
24369 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_1(void * jarg1) {
24370   void * jresult ;
24371   NativeImageInterface *arg1 = 0 ;
24372   Dali::Texture result;
24373
24374   arg1 = (NativeImageInterface *)jarg1;
24375   if (!arg1) {
24376     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
24377     return 0;
24378   }
24379   {
24380     try {
24381       result = Dali::Texture::New(*arg1);
24382     } catch (std::out_of_range& e) {
24383       {
24384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24385       };
24386     } catch (std::exception& e) {
24387       {
24388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24389       };
24390     } catch (Dali::DaliException e) {
24391       {
24392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24393       };
24394     } catch (...) {
24395       {
24396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24397       };
24398     }
24399   }
24400
24401   jresult = new Dali::Texture((const Dali::Texture &)result);
24402   return jresult;
24403 }
24404
24405
24406 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_0() {
24407   void * jresult ;
24408   Dali::Texture *result = 0 ;
24409
24410   {
24411     try {
24412       result = (Dali::Texture *)new Dali::Texture();
24413     } catch (std::out_of_range& e) {
24414       {
24415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24416       };
24417     } catch (std::exception& e) {
24418       {
24419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24420       };
24421     } catch (Dali::DaliException e) {
24422       {
24423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24424       };
24425     } catch (...) {
24426       {
24427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24428       };
24429     }
24430   }
24431
24432   jresult = (void *)result;
24433   return jresult;
24434 }
24435
24436
24437 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Texture(void * jarg1) {
24438   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24439
24440   arg1 = (Dali::Texture *)jarg1;
24441   {
24442     try {
24443       delete arg1;
24444     } catch (std::out_of_range& e) {
24445       {
24446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24447       };
24448     } catch (std::exception& e) {
24449       {
24450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24451       };
24452     } catch (Dali::DaliException e) {
24453       {
24454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24455       };
24456     } catch (...) {
24457       {
24458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24459       };
24460     }
24461   }
24462
24463 }
24464
24465
24466 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_1(void * jarg1) {
24467   void * jresult ;
24468   Dali::Texture *arg1 = 0 ;
24469   Dali::Texture *result = 0 ;
24470
24471   arg1 = (Dali::Texture *)jarg1;
24472   if (!arg1) {
24473     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
24474     return 0;
24475   }
24476   {
24477     try {
24478       result = (Dali::Texture *)new Dali::Texture((Dali::Texture const &)*arg1);
24479     } catch (std::out_of_range& e) {
24480       {
24481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24482       };
24483     } catch (std::exception& e) {
24484       {
24485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24486       };
24487     } catch (Dali::DaliException e) {
24488       {
24489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24490       };
24491     } catch (...) {
24492       {
24493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24494       };
24495     }
24496   }
24497
24498   jresult = (void *)result;
24499   return jresult;
24500 }
24501
24502
24503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_DownCast(void * jarg1) {
24504   void * jresult ;
24505   Dali::BaseHandle arg1 ;
24506   Dali::BaseHandle *argp1 ;
24507   Dali::Texture result;
24508
24509   argp1 = (Dali::BaseHandle *)jarg1;
24510   if (!argp1) {
24511     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24512     return 0;
24513   }
24514   arg1 = *argp1;
24515   {
24516     try {
24517       result = Dali::Texture::DownCast(arg1);
24518     } catch (std::out_of_range& e) {
24519       {
24520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24521       };
24522     } catch (std::exception& e) {
24523       {
24524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24525       };
24526     } catch (Dali::DaliException e) {
24527       {
24528         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24529       };
24530     } catch (...) {
24531       {
24532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24533       };
24534     }
24535   }
24536
24537   jresult = new Dali::Texture((const Dali::Texture &)result);
24538   return jresult;
24539 }
24540
24541
24542 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_Assign(void * jarg1, void * jarg2) {
24543   void * jresult ;
24544   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24545   Dali::Texture *arg2 = 0 ;
24546   Dali::Texture *result = 0 ;
24547
24548   arg1 = (Dali::Texture *)jarg1;
24549   arg2 = (Dali::Texture *)jarg2;
24550   if (!arg2) {
24551     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
24552     return 0;
24553   }
24554   {
24555     try {
24556       result = (Dali::Texture *) &(arg1)->operator =((Dali::Texture const &)*arg2);
24557     } catch (std::out_of_range& e) {
24558       {
24559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24560       };
24561     } catch (std::exception& e) {
24562       {
24563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24564       };
24565     } catch (Dali::DaliException e) {
24566       {
24567         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24568       };
24569     } catch (...) {
24570       {
24571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24572       };
24573     }
24574   }
24575
24576   jresult = (void *)result;
24577   return jresult;
24578 }
24579
24580
24581 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_Upload__SWIG_0(void * jarg1, void * jarg2) {
24582   unsigned int jresult ;
24583   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24584   Dali::PixelData arg2 ;
24585   Dali::PixelData *argp2 ;
24586   bool result;
24587
24588   arg1 = (Dali::Texture *)jarg1;
24589   argp2 = (Dali::PixelData *)jarg2;
24590   if (!argp2) {
24591     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
24592     return 0;
24593   }
24594   arg2 = *argp2;
24595   {
24596     try {
24597       result = (bool)(arg1)->Upload(arg2);
24598     } catch (std::out_of_range& e) {
24599       {
24600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24601       };
24602     } catch (std::exception& e) {
24603       {
24604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24605       };
24606     } catch (Dali::DaliException e) {
24607       {
24608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24609       };
24610     } catch (...) {
24611       {
24612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24613       };
24614     }
24615   }
24616
24617   jresult = result;
24618   return jresult;
24619 }
24620
24621
24622 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) {
24623   unsigned int jresult ;
24624   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24625   Dali::PixelData arg2 ;
24626   unsigned int arg3 ;
24627   unsigned int arg4 ;
24628   unsigned int arg5 ;
24629   unsigned int arg6 ;
24630   unsigned int arg7 ;
24631   unsigned int arg8 ;
24632   Dali::PixelData *argp2 ;
24633   bool result;
24634
24635   arg1 = (Dali::Texture *)jarg1;
24636   argp2 = (Dali::PixelData *)jarg2;
24637   if (!argp2) {
24638     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
24639     return 0;
24640   }
24641   arg2 = *argp2;
24642   arg3 = (unsigned int)jarg3;
24643   arg4 = (unsigned int)jarg4;
24644   arg5 = (unsigned int)jarg5;
24645   arg6 = (unsigned int)jarg6;
24646   arg7 = (unsigned int)jarg7;
24647   arg8 = (unsigned int)jarg8;
24648   {
24649     try {
24650       result = (bool)(arg1)->Upload(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
24651     } catch (std::out_of_range& e) {
24652       {
24653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24654       };
24655     } catch (std::exception& e) {
24656       {
24657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24658       };
24659     } catch (Dali::DaliException e) {
24660       {
24661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24662       };
24663     } catch (...) {
24664       {
24665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24666       };
24667     }
24668   }
24669
24670   jresult = result;
24671   return jresult;
24672 }
24673
24674
24675 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Texture_GenerateMipmaps(void * jarg1) {
24676   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24677
24678   arg1 = (Dali::Texture *)jarg1;
24679   {
24680     try {
24681       (arg1)->GenerateMipmaps();
24682     } catch (std::out_of_range& e) {
24683       {
24684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24685       };
24686     } catch (std::exception& e) {
24687       {
24688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24689       };
24690     } catch (Dali::DaliException e) {
24691       {
24692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24693       };
24694     } catch (...) {
24695       {
24696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24697       };
24698     }
24699   }
24700
24701 }
24702
24703
24704 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetWidth(void * jarg1) {
24705   unsigned int jresult ;
24706   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24707   unsigned int result;
24708
24709   arg1 = (Dali::Texture *)jarg1;
24710   {
24711     try {
24712       result = (unsigned int)((Dali::Texture const *)arg1)->GetWidth();
24713     } catch (std::out_of_range& e) {
24714       {
24715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24716       };
24717     } catch (std::exception& e) {
24718       {
24719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24720       };
24721     } catch (Dali::DaliException e) {
24722       {
24723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24724       };
24725     } catch (...) {
24726       {
24727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24728       };
24729     }
24730   }
24731
24732   jresult = result;
24733   return jresult;
24734 }
24735
24736
24737 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetHeight(void * jarg1) {
24738   unsigned int jresult ;
24739   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24740   unsigned int result;
24741
24742   arg1 = (Dali::Texture *)jarg1;
24743   {
24744     try {
24745       result = (unsigned int)((Dali::Texture const *)arg1)->GetHeight();
24746     } catch (std::out_of_range& e) {
24747       {
24748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24749       };
24750     } catch (std::exception& e) {
24751       {
24752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24753       };
24754     } catch (Dali::DaliException e) {
24755       {
24756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24757       };
24758     } catch (...) {
24759       {
24760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24761       };
24762     }
24763   }
24764
24765   jresult = result;
24766   return jresult;
24767 }
24768
24769
24770 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_2(void * jarg1) {
24771   void * jresult ;
24772   Dali::Internal::Texture *arg1 = (Dali::Internal::Texture *) 0 ;
24773   Dali::Texture *result = 0 ;
24774
24775   arg1 = (Dali::Internal::Texture *)jarg1;
24776   {
24777     try {
24778       result = (Dali::Texture *)new Dali::Texture(arg1);
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_Sampler_New() {
24804   void * jresult ;
24805   Dali::Sampler result;
24806
24807   {
24808     try {
24809       result = Dali::Sampler::New();
24810     } catch (std::out_of_range& e) {
24811       {
24812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24813       };
24814     } catch (std::exception& e) {
24815       {
24816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24817       };
24818     } catch (Dali::DaliException e) {
24819       {
24820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24821       };
24822     } catch (...) {
24823       {
24824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24825       };
24826     }
24827   }
24828
24829   jresult = new Dali::Sampler((const Dali::Sampler &)result);
24830   return jresult;
24831 }
24832
24833
24834 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_0() {
24835   void * jresult ;
24836   Dali::Sampler *result = 0 ;
24837
24838   {
24839     try {
24840       result = (Dali::Sampler *)new Dali::Sampler();
24841     } catch (std::out_of_range& e) {
24842       {
24843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24844       };
24845     } catch (std::exception& e) {
24846       {
24847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24848       };
24849     } catch (Dali::DaliException e) {
24850       {
24851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24852       };
24853     } catch (...) {
24854       {
24855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24856       };
24857     }
24858   }
24859
24860   jresult = (void *)result;
24861   return jresult;
24862 }
24863
24864
24865 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Sampler(void * jarg1) {
24866   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24867
24868   arg1 = (Dali::Sampler *)jarg1;
24869   {
24870     try {
24871       delete arg1;
24872     } catch (std::out_of_range& e) {
24873       {
24874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24875       };
24876     } catch (std::exception& e) {
24877       {
24878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24879       };
24880     } catch (Dali::DaliException e) {
24881       {
24882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24883       };
24884     } catch (...) {
24885       {
24886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24887       };
24888     }
24889   }
24890
24891 }
24892
24893
24894 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_1(void * jarg1) {
24895   void * jresult ;
24896   Dali::Sampler *arg1 = 0 ;
24897   Dali::Sampler *result = 0 ;
24898
24899   arg1 = (Dali::Sampler *)jarg1;
24900   if (!arg1) {
24901     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
24902     return 0;
24903   }
24904   {
24905     try {
24906       result = (Dali::Sampler *)new Dali::Sampler((Dali::Sampler const &)*arg1);
24907     } catch (std::out_of_range& e) {
24908       {
24909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24910       };
24911     } catch (std::exception& e) {
24912       {
24913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24914       };
24915     } catch (Dali::DaliException e) {
24916       {
24917         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24918       };
24919     } catch (...) {
24920       {
24921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24922       };
24923     }
24924   }
24925
24926   jresult = (void *)result;
24927   return jresult;
24928 }
24929
24930
24931 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_DownCast(void * jarg1) {
24932   void * jresult ;
24933   Dali::BaseHandle arg1 ;
24934   Dali::BaseHandle *argp1 ;
24935   Dali::Sampler result;
24936
24937   argp1 = (Dali::BaseHandle *)jarg1;
24938   if (!argp1) {
24939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24940     return 0;
24941   }
24942   arg1 = *argp1;
24943   {
24944     try {
24945       result = Dali::Sampler::DownCast(arg1);
24946     } catch (std::out_of_range& e) {
24947       {
24948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24949       };
24950     } catch (std::exception& e) {
24951       {
24952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24953       };
24954     } catch (Dali::DaliException e) {
24955       {
24956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24957       };
24958     } catch (...) {
24959       {
24960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24961       };
24962     }
24963   }
24964
24965   jresult = new Dali::Sampler((const Dali::Sampler &)result);
24966   return jresult;
24967 }
24968
24969
24970 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_Assign(void * jarg1, void * jarg2) {
24971   void * jresult ;
24972   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24973   Dali::Sampler *arg2 = 0 ;
24974   Dali::Sampler *result = 0 ;
24975
24976   arg1 = (Dali::Sampler *)jarg1;
24977   arg2 = (Dali::Sampler *)jarg2;
24978   if (!arg2) {
24979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
24980     return 0;
24981   }
24982   {
24983     try {
24984       result = (Dali::Sampler *) &(arg1)->operator =((Dali::Sampler const &)*arg2);
24985     } catch (std::out_of_range& e) {
24986       {
24987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24988       };
24989     } catch (std::exception& e) {
24990       {
24991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24992       };
24993     } catch (Dali::DaliException e) {
24994       {
24995         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24996       };
24997     } catch (...) {
24998       {
24999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25000       };
25001     }
25002   }
25003
25004   jresult = (void *)result;
25005   return jresult;
25006 }
25007
25008
25009 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetFilterMode(void * jarg1, int jarg2, int jarg3) {
25010   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
25011   Dali::FilterMode::Type arg2 ;
25012   Dali::FilterMode::Type arg3 ;
25013
25014   arg1 = (Dali::Sampler *)jarg1;
25015   arg2 = (Dali::FilterMode::Type)jarg2;
25016   arg3 = (Dali::FilterMode::Type)jarg3;
25017   {
25018     try {
25019       (arg1)->SetFilterMode(arg2,arg3);
25020     } catch (std::out_of_range& e) {
25021       {
25022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25023       };
25024     } catch (std::exception& e) {
25025       {
25026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25027       };
25028     } catch (Dali::DaliException e) {
25029       {
25030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25031       };
25032     } catch (...) {
25033       {
25034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25035       };
25036     }
25037   }
25038
25039 }
25040
25041
25042 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_0(void * jarg1, int jarg2, int jarg3) {
25043   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
25044   Dali::WrapMode::Type arg2 ;
25045   Dali::WrapMode::Type arg3 ;
25046
25047   arg1 = (Dali::Sampler *)jarg1;
25048   arg2 = (Dali::WrapMode::Type)jarg2;
25049   arg3 = (Dali::WrapMode::Type)jarg3;
25050   {
25051     try {
25052       (arg1)->SetWrapMode(arg2,arg3);
25053     } catch (std::out_of_range& e) {
25054       {
25055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25056       };
25057     } catch (std::exception& e) {
25058       {
25059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25060       };
25061     } catch (Dali::DaliException e) {
25062       {
25063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25064       };
25065     } catch (...) {
25066       {
25067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25068       };
25069     }
25070   }
25071
25072 }
25073
25074
25075 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_1(void * jarg1, int jarg2, int jarg3, int jarg4) {
25076   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
25077   Dali::WrapMode::Type arg2 ;
25078   Dali::WrapMode::Type arg3 ;
25079   Dali::WrapMode::Type arg4 ;
25080
25081   arg1 = (Dali::Sampler *)jarg1;
25082   arg2 = (Dali::WrapMode::Type)jarg2;
25083   arg3 = (Dali::WrapMode::Type)jarg3;
25084   arg4 = (Dali::WrapMode::Type)jarg4;
25085   {
25086     try {
25087       (arg1)->SetWrapMode(arg2,arg3,arg4);
25088     } catch (std::out_of_range& e) {
25089       {
25090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25091       };
25092     } catch (std::exception& e) {
25093       {
25094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25095       };
25096     } catch (Dali::DaliException e) {
25097       {
25098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25099       };
25100     } catch (...) {
25101       {
25102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25103       };
25104     }
25105   }
25106
25107 }
25108
25109
25110 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_New() {
25111   void * jresult ;
25112   Dali::TextureSet result;
25113
25114   {
25115     try {
25116       result = Dali::TextureSet::New();
25117     } catch (std::out_of_range& e) {
25118       {
25119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25120       };
25121     } catch (std::exception& e) {
25122       {
25123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25124       };
25125     } catch (Dali::DaliException e) {
25126       {
25127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25128       };
25129     } catch (...) {
25130       {
25131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25132       };
25133     }
25134   }
25135
25136   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
25137   return jresult;
25138 }
25139
25140
25141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_0() {
25142   void * jresult ;
25143   Dali::TextureSet *result = 0 ;
25144
25145   {
25146     try {
25147       result = (Dali::TextureSet *)new Dali::TextureSet();
25148     } catch (std::out_of_range& e) {
25149       {
25150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25151       };
25152     } catch (std::exception& e) {
25153       {
25154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25155       };
25156     } catch (Dali::DaliException e) {
25157       {
25158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25159       };
25160     } catch (...) {
25161       {
25162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25163       };
25164     }
25165   }
25166
25167   jresult = (void *)result;
25168   return jresult;
25169 }
25170
25171
25172 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextureSet(void * jarg1) {
25173   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25174
25175   arg1 = (Dali::TextureSet *)jarg1;
25176   {
25177     try {
25178       delete arg1;
25179     } catch (std::out_of_range& e) {
25180       {
25181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25182       };
25183     } catch (std::exception& e) {
25184       {
25185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25186       };
25187     } catch (Dali::DaliException e) {
25188       {
25189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25190       };
25191     } catch (...) {
25192       {
25193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25194       };
25195     }
25196   }
25197
25198 }
25199
25200
25201 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_1(void * jarg1) {
25202   void * jresult ;
25203   Dali::TextureSet *arg1 = 0 ;
25204   Dali::TextureSet *result = 0 ;
25205
25206   arg1 = (Dali::TextureSet *)jarg1;
25207   if (!arg1) {
25208     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
25209     return 0;
25210   }
25211   {
25212     try {
25213       result = (Dali::TextureSet *)new Dali::TextureSet((Dali::TextureSet const &)*arg1);
25214     } catch (std::out_of_range& e) {
25215       {
25216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25217       };
25218     } catch (std::exception& e) {
25219       {
25220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25221       };
25222     } catch (Dali::DaliException e) {
25223       {
25224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25225       };
25226     } catch (...) {
25227       {
25228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25229       };
25230     }
25231   }
25232
25233   jresult = (void *)result;
25234   return jresult;
25235 }
25236
25237
25238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_DownCast(void * jarg1) {
25239   void * jresult ;
25240   Dali::BaseHandle arg1 ;
25241   Dali::BaseHandle *argp1 ;
25242   Dali::TextureSet result;
25243
25244   argp1 = (Dali::BaseHandle *)jarg1;
25245   if (!argp1) {
25246     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25247     return 0;
25248   }
25249   arg1 = *argp1;
25250   {
25251     try {
25252       result = Dali::TextureSet::DownCast(arg1);
25253     } catch (std::out_of_range& e) {
25254       {
25255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25256       };
25257     } catch (std::exception& e) {
25258       {
25259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25260       };
25261     } catch (Dali::DaliException e) {
25262       {
25263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25264       };
25265     } catch (...) {
25266       {
25267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25268       };
25269     }
25270   }
25271
25272   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
25273   return jresult;
25274 }
25275
25276
25277 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_Assign(void * jarg1, void * jarg2) {
25278   void * jresult ;
25279   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25280   Dali::TextureSet *arg2 = 0 ;
25281   Dali::TextureSet *result = 0 ;
25282
25283   arg1 = (Dali::TextureSet *)jarg1;
25284   arg2 = (Dali::TextureSet *)jarg2;
25285   if (!arg2) {
25286     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
25287     return 0;
25288   }
25289   {
25290     try {
25291       result = (Dali::TextureSet *) &(arg1)->operator =((Dali::TextureSet const &)*arg2);
25292     } catch (std::out_of_range& e) {
25293       {
25294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25295       };
25296     } catch (std::exception& e) {
25297       {
25298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25299       };
25300     } catch (Dali::DaliException e) {
25301       {
25302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25303       };
25304     } catch (...) {
25305       {
25306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25307       };
25308     }
25309   }
25310
25311   jresult = (void *)result;
25312   return jresult;
25313 }
25314
25315
25316 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetTexture(void * jarg1, unsigned long jarg2, void * jarg3) {
25317   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25318   size_t arg2 ;
25319   Dali::Texture arg3 ;
25320   Dali::Texture *argp3 ;
25321
25322   arg1 = (Dali::TextureSet *)jarg1;
25323   arg2 = (size_t)jarg2;
25324   argp3 = (Dali::Texture *)jarg3;
25325   if (!argp3) {
25326     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
25327     return ;
25328   }
25329   arg3 = *argp3;
25330   {
25331     try {
25332       (arg1)->SetTexture(arg2,arg3);
25333     } catch (std::out_of_range& e) {
25334       {
25335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25336       };
25337     } catch (std::exception& e) {
25338       {
25339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25340       };
25341     } catch (Dali::DaliException e) {
25342       {
25343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25344       };
25345     } catch (...) {
25346       {
25347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25348       };
25349     }
25350   }
25351
25352 }
25353
25354
25355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetTexture(void * jarg1, unsigned long jarg2) {
25356   void * jresult ;
25357   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25358   size_t arg2 ;
25359   Dali::Texture result;
25360
25361   arg1 = (Dali::TextureSet *)jarg1;
25362   arg2 = (size_t)jarg2;
25363   {
25364     try {
25365       result = ((Dali::TextureSet const *)arg1)->GetTexture(arg2);
25366     } catch (std::out_of_range& e) {
25367       {
25368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25369       };
25370     } catch (std::exception& e) {
25371       {
25372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25373       };
25374     } catch (Dali::DaliException e) {
25375       {
25376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25377       };
25378     } catch (...) {
25379       {
25380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25381       };
25382     }
25383   }
25384
25385   jresult = new Dali::Texture((const Dali::Texture &)result);
25386   return jresult;
25387 }
25388
25389
25390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetSampler(void * jarg1, unsigned long jarg2, void * jarg3) {
25391   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25392   size_t arg2 ;
25393   Dali::Sampler arg3 ;
25394   Dali::Sampler *argp3 ;
25395
25396   arg1 = (Dali::TextureSet *)jarg1;
25397   arg2 = (size_t)jarg2;
25398   argp3 = (Dali::Sampler *)jarg3;
25399   if (!argp3) {
25400     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Sampler", 0);
25401     return ;
25402   }
25403   arg3 = *argp3;
25404   {
25405     try {
25406       (arg1)->SetSampler(arg2,arg3);
25407     } catch (std::out_of_range& e) {
25408       {
25409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25410       };
25411     } catch (std::exception& e) {
25412       {
25413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25414       };
25415     } catch (Dali::DaliException e) {
25416       {
25417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25418       };
25419     } catch (...) {
25420       {
25421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25422       };
25423     }
25424   }
25425
25426 }
25427
25428
25429 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetSampler(void * jarg1, unsigned long jarg2) {
25430   void * jresult ;
25431   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25432   size_t arg2 ;
25433   Dali::Sampler result;
25434
25435   arg1 = (Dali::TextureSet *)jarg1;
25436   arg2 = (size_t)jarg2;
25437   {
25438     try {
25439       result = ((Dali::TextureSet const *)arg1)->GetSampler(arg2);
25440     } catch (std::out_of_range& e) {
25441       {
25442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25443       };
25444     } catch (std::exception& e) {
25445       {
25446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25447       };
25448     } catch (Dali::DaliException e) {
25449       {
25450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25451       };
25452     } catch (...) {
25453       {
25454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25455       };
25456     }
25457   }
25458
25459   jresult = new Dali::Sampler((const Dali::Sampler &)result);
25460   return jresult;
25461 }
25462
25463
25464 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextureSet_GetTextureCount(void * jarg1) {
25465   unsigned long jresult ;
25466   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25467   size_t result;
25468
25469   arg1 = (Dali::TextureSet *)jarg1;
25470   {
25471     try {
25472       result = ((Dali::TextureSet const *)arg1)->GetTextureCount();
25473     } catch (std::out_of_range& e) {
25474       {
25475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25476       };
25477     } catch (std::exception& e) {
25478       {
25479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25480       };
25481     } catch (Dali::DaliException e) {
25482       {
25483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25484       };
25485     } catch (...) {
25486       {
25487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25488       };
25489     }
25490   }
25491
25492   jresult = (unsigned long)result;
25493   return jresult;
25494 }
25495
25496
25497 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_New(void * jarg1) {
25498   void * jresult ;
25499   Dali::Property::Map *arg1 = 0 ;
25500   Dali::PropertyBuffer result;
25501
25502   arg1 = (Dali::Property::Map *)jarg1;
25503   if (!arg1) {
25504     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
25505     return 0;
25506   }
25507   {
25508     try {
25509       result = Dali::PropertyBuffer::New(*arg1);
25510     } catch (std::out_of_range& e) {
25511       {
25512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25513       };
25514     } catch (std::exception& e) {
25515       {
25516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25517       };
25518     } catch (Dali::DaliException e) {
25519       {
25520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25521       };
25522     } catch (...) {
25523       {
25524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25525       };
25526     }
25527   }
25528
25529   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
25530   return jresult;
25531 }
25532
25533
25534 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_0() {
25535   void * jresult ;
25536   Dali::PropertyBuffer *result = 0 ;
25537
25538   {
25539     try {
25540       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer();
25541     } catch (std::out_of_range& e) {
25542       {
25543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25544       };
25545     } catch (std::exception& e) {
25546       {
25547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25548       };
25549     } catch (Dali::DaliException e) {
25550       {
25551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25552       };
25553     } catch (...) {
25554       {
25555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25556       };
25557     }
25558   }
25559
25560   jresult = (void *)result;
25561   return jresult;
25562 }
25563
25564
25565 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyBuffer(void * jarg1) {
25566   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25567
25568   arg1 = (Dali::PropertyBuffer *)jarg1;
25569   {
25570     try {
25571       delete arg1;
25572     } catch (std::out_of_range& e) {
25573       {
25574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25575       };
25576     } catch (std::exception& e) {
25577       {
25578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25579       };
25580     } catch (Dali::DaliException e) {
25581       {
25582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25583       };
25584     } catch (...) {
25585       {
25586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25587       };
25588     }
25589   }
25590
25591 }
25592
25593
25594 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_1(void * jarg1) {
25595   void * jresult ;
25596   Dali::PropertyBuffer *arg1 = 0 ;
25597   Dali::PropertyBuffer *result = 0 ;
25598
25599   arg1 = (Dali::PropertyBuffer *)jarg1;
25600   if (!arg1) {
25601     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
25602     return 0;
25603   }
25604   {
25605     try {
25606       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer((Dali::PropertyBuffer const &)*arg1);
25607     } catch (std::out_of_range& e) {
25608       {
25609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25610       };
25611     } catch (std::exception& e) {
25612       {
25613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25614       };
25615     } catch (Dali::DaliException e) {
25616       {
25617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25618       };
25619     } catch (...) {
25620       {
25621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25622       };
25623     }
25624   }
25625
25626   jresult = (void *)result;
25627   return jresult;
25628 }
25629
25630
25631 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_DownCast(void * jarg1) {
25632   void * jresult ;
25633   Dali::BaseHandle arg1 ;
25634   Dali::BaseHandle *argp1 ;
25635   Dali::PropertyBuffer result;
25636
25637   argp1 = (Dali::BaseHandle *)jarg1;
25638   if (!argp1) {
25639     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25640     return 0;
25641   }
25642   arg1 = *argp1;
25643   {
25644     try {
25645       result = Dali::PropertyBuffer::DownCast(arg1);
25646     } catch (std::out_of_range& e) {
25647       {
25648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25649       };
25650     } catch (std::exception& e) {
25651       {
25652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25653       };
25654     } catch (Dali::DaliException e) {
25655       {
25656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25657       };
25658     } catch (...) {
25659       {
25660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25661       };
25662     }
25663   }
25664
25665   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
25666   return jresult;
25667 }
25668
25669
25670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_Assign(void * jarg1, void * jarg2) {
25671   void * jresult ;
25672   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25673   Dali::PropertyBuffer *arg2 = 0 ;
25674   Dali::PropertyBuffer *result = 0 ;
25675
25676   arg1 = (Dali::PropertyBuffer *)jarg1;
25677   arg2 = (Dali::PropertyBuffer *)jarg2;
25678   if (!arg2) {
25679     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
25680     return 0;
25681   }
25682   {
25683     try {
25684       result = (Dali::PropertyBuffer *) &(arg1)->operator =((Dali::PropertyBuffer const &)*arg2);
25685     } catch (std::out_of_range& e) {
25686       {
25687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25688       };
25689     } catch (std::exception& e) {
25690       {
25691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25692       };
25693     } catch (Dali::DaliException e) {
25694       {
25695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25696       };
25697     } catch (...) {
25698       {
25699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25700       };
25701     }
25702   }
25703
25704   jresult = (void *)result;
25705   return jresult;
25706 }
25707
25708
25709 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyBuffer_SetData(void * jarg1, void * jarg2, unsigned long jarg3) {
25710   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25711   void *arg2 = (void *) 0 ;
25712   std::size_t arg3 ;
25713
25714   arg1 = (Dali::PropertyBuffer *)jarg1;
25715   arg2 = jarg2;
25716   arg3 = (std::size_t)jarg3;
25717   {
25718     try {
25719       (arg1)->SetData((void const *)arg2,arg3);
25720     } catch (std::out_of_range& e) {
25721       {
25722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25723       };
25724     } catch (std::exception& e) {
25725       {
25726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25727       };
25728     } catch (Dali::DaliException e) {
25729       {
25730         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25731       };
25732     } catch (...) {
25733       {
25734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25735       };
25736     }
25737   }
25738
25739 }
25740
25741
25742 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyBuffer_GetSize(void * jarg1) {
25743   unsigned long jresult ;
25744   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25745   std::size_t result;
25746
25747   arg1 = (Dali::PropertyBuffer *)jarg1;
25748   {
25749     try {
25750       result = ((Dali::PropertyBuffer const *)arg1)->GetSize();
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 = (unsigned long)result;
25771   return jresult;
25772 }
25773
25774
25775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_New() {
25776   void * jresult ;
25777   Dali::Geometry result;
25778
25779   {
25780     try {
25781       result = Dali::Geometry::New();
25782     } catch (std::out_of_range& e) {
25783       {
25784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25785       };
25786     } catch (std::exception& e) {
25787       {
25788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25789       };
25790     } catch (Dali::DaliException e) {
25791       {
25792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25793       };
25794     } catch (...) {
25795       {
25796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25797       };
25798     }
25799   }
25800
25801   jresult = new Dali::Geometry((const Dali::Geometry &)result);
25802   return jresult;
25803 }
25804
25805
25806 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_0() {
25807   void * jresult ;
25808   Dali::Geometry *result = 0 ;
25809
25810   {
25811     try {
25812       result = (Dali::Geometry *)new Dali::Geometry();
25813     } catch (std::out_of_range& e) {
25814       {
25815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25816       };
25817     } catch (std::exception& e) {
25818       {
25819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25820       };
25821     } catch (Dali::DaliException e) {
25822       {
25823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25824       };
25825     } catch (...) {
25826       {
25827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25828       };
25829     }
25830   }
25831
25832   jresult = (void *)result;
25833   return jresult;
25834 }
25835
25836
25837 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Geometry(void * jarg1) {
25838   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25839
25840   arg1 = (Dali::Geometry *)jarg1;
25841   {
25842     try {
25843       delete arg1;
25844     } catch (std::out_of_range& e) {
25845       {
25846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25847       };
25848     } catch (std::exception& e) {
25849       {
25850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25851       };
25852     } catch (Dali::DaliException e) {
25853       {
25854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25855       };
25856     } catch (...) {
25857       {
25858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25859       };
25860     }
25861   }
25862
25863 }
25864
25865
25866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_1(void * jarg1) {
25867   void * jresult ;
25868   Dali::Geometry *arg1 = 0 ;
25869   Dali::Geometry *result = 0 ;
25870
25871   arg1 = (Dali::Geometry *)jarg1;
25872   if (!arg1) {
25873     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
25874     return 0;
25875   }
25876   {
25877     try {
25878       result = (Dali::Geometry *)new Dali::Geometry((Dali::Geometry const &)*arg1);
25879     } catch (std::out_of_range& e) {
25880       {
25881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25882       };
25883     } catch (std::exception& e) {
25884       {
25885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25886       };
25887     } catch (Dali::DaliException e) {
25888       {
25889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25890       };
25891     } catch (...) {
25892       {
25893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25894       };
25895     }
25896   }
25897
25898   jresult = (void *)result;
25899   return jresult;
25900 }
25901
25902
25903 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_DownCast(void * jarg1) {
25904   void * jresult ;
25905   Dali::BaseHandle arg1 ;
25906   Dali::BaseHandle *argp1 ;
25907   Dali::Geometry result;
25908
25909   argp1 = (Dali::BaseHandle *)jarg1;
25910   if (!argp1) {
25911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25912     return 0;
25913   }
25914   arg1 = *argp1;
25915   {
25916     try {
25917       result = Dali::Geometry::DownCast(arg1);
25918     } catch (std::out_of_range& e) {
25919       {
25920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25921       };
25922     } catch (std::exception& e) {
25923       {
25924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25925       };
25926     } catch (Dali::DaliException e) {
25927       {
25928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25929       };
25930     } catch (...) {
25931       {
25932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25933       };
25934     }
25935   }
25936
25937   jresult = new Dali::Geometry((const Dali::Geometry &)result);
25938   return jresult;
25939 }
25940
25941
25942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_Assign(void * jarg1, void * jarg2) {
25943   void * jresult ;
25944   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25945   Dali::Geometry *arg2 = 0 ;
25946   Dali::Geometry *result = 0 ;
25947
25948   arg1 = (Dali::Geometry *)jarg1;
25949   arg2 = (Dali::Geometry *)jarg2;
25950   if (!arg2) {
25951     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
25952     return 0;
25953   }
25954   {
25955     try {
25956       result = (Dali::Geometry *) &(arg1)->operator =((Dali::Geometry const &)*arg2);
25957     } catch (std::out_of_range& e) {
25958       {
25959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25960       };
25961     } catch (std::exception& e) {
25962       {
25963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25964       };
25965     } catch (Dali::DaliException e) {
25966       {
25967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25968       };
25969     } catch (...) {
25970       {
25971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25972       };
25973     }
25974   }
25975
25976   jresult = (void *)result;
25977   return jresult;
25978 }
25979
25980
25981 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_AddVertexBuffer(void * jarg1, void * jarg2) {
25982   unsigned long jresult ;
25983   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25984   Dali::PropertyBuffer *arg2 = 0 ;
25985   std::size_t result;
25986
25987   arg1 = (Dali::Geometry *)jarg1;
25988   arg2 = (Dali::PropertyBuffer *)jarg2;
25989   if (!arg2) {
25990     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer & type is null", 0);
25991     return 0;
25992   }
25993   {
25994     try {
25995       result = (arg1)->AddVertexBuffer(*arg2);
25996     } catch (std::out_of_range& e) {
25997       {
25998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25999       };
26000     } catch (std::exception& e) {
26001       {
26002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26003       };
26004     } catch (Dali::DaliException e) {
26005       {
26006         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26007       };
26008     } catch (...) {
26009       {
26010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26011       };
26012     }
26013   }
26014
26015   jresult = (unsigned long)result;
26016   return jresult;
26017 }
26018
26019
26020 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_GetNumberOfVertexBuffers(void * jarg1) {
26021   unsigned long jresult ;
26022   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
26023   std::size_t result;
26024
26025   arg1 = (Dali::Geometry *)jarg1;
26026   {
26027     try {
26028       result = ((Dali::Geometry const *)arg1)->GetNumberOfVertexBuffers();
26029     } catch (std::out_of_range& e) {
26030       {
26031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26032       };
26033     } catch (std::exception& e) {
26034       {
26035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26036       };
26037     } catch (Dali::DaliException e) {
26038       {
26039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26040       };
26041     } catch (...) {
26042       {
26043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26044       };
26045     }
26046   }
26047
26048   jresult = (unsigned long)result;
26049   return jresult;
26050 }
26051
26052
26053 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_RemoveVertexBuffer(void * jarg1, unsigned long jarg2) {
26054   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
26055   std::size_t arg2 ;
26056
26057   arg1 = (Dali::Geometry *)jarg1;
26058   arg2 = (std::size_t)jarg2;
26059   {
26060     try {
26061       (arg1)->RemoveVertexBuffer(arg2);
26062     } catch (std::out_of_range& e) {
26063       {
26064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26065       };
26066     } catch (std::exception& e) {
26067       {
26068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26069       };
26070     } catch (Dali::DaliException e) {
26071       {
26072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26073       };
26074     } catch (...) {
26075       {
26076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26077       };
26078     }
26079   }
26080
26081 }
26082
26083
26084 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetIndexBuffer(void * jarg1, unsigned short* jarg2, unsigned long jarg3) {
26085   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
26086   unsigned short *arg2 = (unsigned short *) 0 ;
26087   size_t arg3 ;
26088
26089   arg1 = (Dali::Geometry *)jarg1;
26090   arg2 = jarg2;
26091   arg3 = (size_t)jarg3;
26092   {
26093     try {
26094       (arg1)->SetIndexBuffer((unsigned short const *)arg2,arg3);
26095     } catch (std::out_of_range& e) {
26096       {
26097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26098       };
26099     } catch (std::exception& e) {
26100       {
26101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26102       };
26103     } catch (Dali::DaliException e) {
26104       {
26105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26106       };
26107     } catch (...) {
26108       {
26109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26110       };
26111     }
26112   }
26113
26114
26115
26116 }
26117
26118
26119 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetType(void * jarg1, int jarg2) {
26120   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
26121   Dali::Geometry::Type arg2 ;
26122
26123   arg1 = (Dali::Geometry *)jarg1;
26124   arg2 = (Dali::Geometry::Type)jarg2;
26125   {
26126     try {
26127       (arg1)->SetType(arg2);
26128     } catch (std::out_of_range& e) {
26129       {
26130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26131       };
26132     } catch (std::exception& e) {
26133       {
26134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26135       };
26136     } catch (Dali::DaliException e) {
26137       {
26138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26139       };
26140     } catch (...) {
26141       {
26142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26143       };
26144     }
26145   }
26146
26147 }
26148
26149
26150 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Geometry_GetType(void * jarg1) {
26151   int jresult ;
26152   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
26153   Dali::Geometry::Type result;
26154
26155   arg1 = (Dali::Geometry *)jarg1;
26156   {
26157     try {
26158       result = (Dali::Geometry::Type)((Dali::Geometry const *)arg1)->GetType();
26159     } catch (std::out_of_range& e) {
26160       {
26161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26162       };
26163     } catch (std::exception& e) {
26164       {
26165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26166       };
26167     } catch (Dali::DaliException e) {
26168       {
26169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26170       };
26171     } catch (...) {
26172       {
26173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26174       };
26175     }
26176   }
26177
26178   jresult = (int)result;
26179   return jresult;
26180 }
26181
26182
26183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Hint() {
26184   void * jresult ;
26185   Dali::Shader::Hint *result = 0 ;
26186
26187   {
26188     try {
26189       result = (Dali::Shader::Hint *)new Dali::Shader::Hint();
26190     } catch (std::out_of_range& e) {
26191       {
26192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26193       };
26194     } catch (std::exception& e) {
26195       {
26196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26197       };
26198     } catch (Dali::DaliException e) {
26199       {
26200         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26201       };
26202     } catch (...) {
26203       {
26204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26205       };
26206     }
26207   }
26208
26209   jresult = (void *)result;
26210   return jresult;
26211 }
26212
26213
26214 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Hint(void * jarg1) {
26215   Dali::Shader::Hint *arg1 = (Dali::Shader::Hint *) 0 ;
26216
26217   arg1 = (Dali::Shader::Hint *)jarg1;
26218   {
26219     try {
26220       delete arg1;
26221     } catch (std::out_of_range& e) {
26222       {
26223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26224       };
26225     } catch (std::exception& e) {
26226       {
26227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26228       };
26229     } catch (Dali::DaliException e) {
26230       {
26231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26232       };
26233     } catch (...) {
26234       {
26235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26236       };
26237     }
26238   }
26239
26240 }
26241
26242
26243 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Shader_Property_PROGRAM_get() {
26244   int jresult ;
26245   int result;
26246
26247   result = (int)Dali::Shader::Property::PROGRAM;
26248   jresult = (int)result;
26249   return jresult;
26250 }
26251
26252
26253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Property() {
26254   void * jresult ;
26255   Dali::Shader::Property *result = 0 ;
26256
26257   {
26258     try {
26259       result = (Dali::Shader::Property *)new Dali::Shader::Property();
26260     } catch (std::out_of_range& e) {
26261       {
26262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26263       };
26264     } catch (std::exception& e) {
26265       {
26266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26267       };
26268     } catch (Dali::DaliException e) {
26269       {
26270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26271       };
26272     } catch (...) {
26273       {
26274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26275       };
26276     }
26277   }
26278
26279   jresult = (void *)result;
26280   return jresult;
26281 }
26282
26283
26284 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Property(void * jarg1) {
26285   Dali::Shader::Property *arg1 = (Dali::Shader::Property *) 0 ;
26286
26287   arg1 = (Dali::Shader::Property *)jarg1;
26288   {
26289     try {
26290       delete arg1;
26291     } catch (std::out_of_range& e) {
26292       {
26293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26294       };
26295     } catch (std::exception& e) {
26296       {
26297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26298       };
26299     } catch (Dali::DaliException e) {
26300       {
26301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26302       };
26303     } catch (...) {
26304       {
26305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26306       };
26307     }
26308   }
26309
26310 }
26311
26312
26313 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_0(char * jarg1, char * jarg2, int jarg3) {
26314   void * jresult ;
26315   std::string *arg1 = 0 ;
26316   std::string *arg2 = 0 ;
26317   Dali::Shader::Hint::Value arg3 ;
26318   Dali::Shader result;
26319
26320   if (!jarg1) {
26321     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26322     return 0;
26323   }
26324   std::string arg1_str(jarg1);
26325   arg1 = &arg1_str;
26326   if (!jarg2) {
26327     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26328     return 0;
26329   }
26330   std::string arg2_str(jarg2);
26331   arg2 = &arg2_str;
26332   arg3 = (Dali::Shader::Hint::Value)jarg3;
26333   {
26334     try {
26335       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2,arg3);
26336     } catch (std::out_of_range& e) {
26337       {
26338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26339       };
26340     } catch (std::exception& e) {
26341       {
26342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26343       };
26344     } catch (Dali::DaliException e) {
26345       {
26346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26347       };
26348     } catch (...) {
26349       {
26350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26351       };
26352     }
26353   }
26354
26355   jresult = new Dali::Shader((const Dali::Shader &)result);
26356
26357   //argout typemap for const std::string&
26358
26359
26360   //argout typemap for const std::string&
26361
26362   return jresult;
26363 }
26364
26365
26366 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_1(char * jarg1, char * jarg2) {
26367   void * jresult ;
26368   std::string *arg1 = 0 ;
26369   std::string *arg2 = 0 ;
26370   Dali::Shader result;
26371
26372   if (!jarg1) {
26373     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26374     return 0;
26375   }
26376   std::string arg1_str(jarg1);
26377   arg1 = &arg1_str;
26378   if (!jarg2) {
26379     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26380     return 0;
26381   }
26382   std::string arg2_str(jarg2);
26383   arg2 = &arg2_str;
26384   {
26385     try {
26386       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2);
26387     } catch (std::out_of_range& e) {
26388       {
26389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26390       };
26391     } catch (std::exception& e) {
26392       {
26393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26394       };
26395     } catch (Dali::DaliException e) {
26396       {
26397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26398       };
26399     } catch (...) {
26400       {
26401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26402       };
26403     }
26404   }
26405
26406   jresult = new Dali::Shader((const Dali::Shader &)result);
26407
26408   //argout typemap for const std::string&
26409
26410
26411   //argout typemap for const std::string&
26412
26413   return jresult;
26414 }
26415
26416
26417 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_0() {
26418   void * jresult ;
26419   Dali::Shader *result = 0 ;
26420
26421   {
26422     try {
26423       result = (Dali::Shader *)new Dali::Shader();
26424     } catch (std::out_of_range& e) {
26425       {
26426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26427       };
26428     } catch (std::exception& e) {
26429       {
26430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26431       };
26432     } catch (Dali::DaliException e) {
26433       {
26434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26435       };
26436     } catch (...) {
26437       {
26438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26439       };
26440     }
26441   }
26442
26443   jresult = (void *)result;
26444   return jresult;
26445 }
26446
26447
26448 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader(void * jarg1) {
26449   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
26450
26451   arg1 = (Dali::Shader *)jarg1;
26452   {
26453     try {
26454       delete arg1;
26455     } catch (std::out_of_range& e) {
26456       {
26457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26458       };
26459     } catch (std::exception& e) {
26460       {
26461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26462       };
26463     } catch (Dali::DaliException e) {
26464       {
26465         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26466       };
26467     } catch (...) {
26468       {
26469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26470       };
26471     }
26472   }
26473
26474 }
26475
26476
26477 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_1(void * jarg1) {
26478   void * jresult ;
26479   Dali::Shader *arg1 = 0 ;
26480   Dali::Shader *result = 0 ;
26481
26482   arg1 = (Dali::Shader *)jarg1;
26483   if (!arg1) {
26484     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
26485     return 0;
26486   }
26487   {
26488     try {
26489       result = (Dali::Shader *)new Dali::Shader((Dali::Shader const &)*arg1);
26490     } catch (std::out_of_range& e) {
26491       {
26492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26493       };
26494     } catch (std::exception& e) {
26495       {
26496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26497       };
26498     } catch (Dali::DaliException e) {
26499       {
26500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26501       };
26502     } catch (...) {
26503       {
26504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26505       };
26506     }
26507   }
26508
26509   jresult = (void *)result;
26510   return jresult;
26511 }
26512
26513
26514 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_DownCast(void * jarg1) {
26515   void * jresult ;
26516   Dali::BaseHandle arg1 ;
26517   Dali::BaseHandle *argp1 ;
26518   Dali::Shader result;
26519
26520   argp1 = (Dali::BaseHandle *)jarg1;
26521   if (!argp1) {
26522     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26523     return 0;
26524   }
26525   arg1 = *argp1;
26526   {
26527     try {
26528       result = Dali::Shader::DownCast(arg1);
26529     } catch (std::out_of_range& e) {
26530       {
26531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26532       };
26533     } catch (std::exception& e) {
26534       {
26535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26536       };
26537     } catch (Dali::DaliException e) {
26538       {
26539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26540       };
26541     } catch (...) {
26542       {
26543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26544       };
26545     }
26546   }
26547
26548   jresult = new Dali::Shader((const Dali::Shader &)result);
26549   return jresult;
26550 }
26551
26552
26553 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_Assign(void * jarg1, void * jarg2) {
26554   void * jresult ;
26555   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
26556   Dali::Shader *arg2 = 0 ;
26557   Dali::Shader *result = 0 ;
26558
26559   arg1 = (Dali::Shader *)jarg1;
26560   arg2 = (Dali::Shader *)jarg2;
26561   if (!arg2) {
26562     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
26563     return 0;
26564   }
26565   {
26566     try {
26567       result = (Dali::Shader *) &(arg1)->operator =((Dali::Shader const &)*arg2);
26568     } catch (std::out_of_range& e) {
26569       {
26570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26571       };
26572     } catch (std::exception& e) {
26573       {
26574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26575       };
26576     } catch (Dali::DaliException e) {
26577       {
26578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26579       };
26580     } catch (...) {
26581       {
26582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26583       };
26584     }
26585   }
26586
26587   jresult = (void *)result;
26588   return jresult;
26589 }
26590
26591
26592 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_INDEX_get() {
26593   int jresult ;
26594   int result;
26595
26596   result = (int)Dali::Renderer::Property::DEPTH_INDEX;
26597   jresult = (int)result;
26598   return jresult;
26599 }
26600
26601
26602 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_FACE_CULLING_MODE_get() {
26603   int jresult ;
26604   int result;
26605
26606   result = (int)Dali::Renderer::Property::FACE_CULLING_MODE;
26607   jresult = (int)result;
26608   return jresult;
26609 }
26610
26611
26612 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_MODE_get() {
26613   int jresult ;
26614   int result;
26615
26616   result = (int)Dali::Renderer::Property::BLEND_MODE;
26617   jresult = (int)result;
26618   return jresult;
26619 }
26620
26621
26622 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_RGB_get() {
26623   int jresult ;
26624   int result;
26625
26626   result = (int)Dali::Renderer::Property::BLEND_EQUATION_RGB;
26627   jresult = (int)result;
26628   return jresult;
26629 }
26630
26631
26632 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_ALPHA_get() {
26633   int jresult ;
26634   int result;
26635
26636   result = (int)Dali::Renderer::Property::BLEND_EQUATION_ALPHA;
26637   jresult = (int)result;
26638   return jresult;
26639 }
26640
26641
26642 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_RGB_get() {
26643   int jresult ;
26644   int result;
26645
26646   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_RGB;
26647   jresult = (int)result;
26648   return jresult;
26649 }
26650
26651
26652 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_RGB_get() {
26653   int jresult ;
26654   int result;
26655
26656   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_RGB;
26657   jresult = (int)result;
26658   return jresult;
26659 }
26660
26661
26662 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_ALPHA_get() {
26663   int jresult ;
26664   int result;
26665
26666   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_ALPHA;
26667   jresult = (int)result;
26668   return jresult;
26669 }
26670
26671
26672 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_ALPHA_get() {
26673   int jresult ;
26674   int result;
26675
26676   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_ALPHA;
26677   jresult = (int)result;
26678   return jresult;
26679 }
26680
26681
26682 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_COLOR_get() {
26683   int jresult ;
26684   int result;
26685
26686   result = (int)Dali::Renderer::Property::BLEND_COLOR;
26687   jresult = (int)result;
26688   return jresult;
26689 }
26690
26691
26692 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_PRE_MULTIPLIED_ALPHA_get() {
26693   int jresult ;
26694   int result;
26695
26696   result = (int)Dali::Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA;
26697   jresult = (int)result;
26698   return jresult;
26699 }
26700
26701
26702 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_FIRST_get() {
26703   int jresult ;
26704   int result;
26705
26706   result = (int)Dali::Renderer::Property::INDEX_RANGE_FIRST;
26707   jresult = (int)result;
26708   return jresult;
26709 }
26710
26711
26712 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_COUNT_get() {
26713   int jresult ;
26714   int result;
26715
26716   result = (int)Dali::Renderer::Property::INDEX_RANGE_COUNT;
26717   jresult = (int)result;
26718   return jresult;
26719 }
26720
26721
26722 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_WRITE_MODE_get() {
26723   int jresult ;
26724   int result;
26725
26726   result = (int)Dali::Renderer::Property::DEPTH_WRITE_MODE;
26727   jresult = (int)result;
26728   return jresult;
26729 }
26730
26731
26732 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_FUNCTION_get() {
26733   int jresult ;
26734   int result;
26735
26736   result = (int)Dali::Renderer::Property::DEPTH_FUNCTION;
26737   jresult = (int)result;
26738   return jresult;
26739 }
26740
26741
26742 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_TEST_MODE_get() {
26743   int jresult ;
26744   int result;
26745
26746   result = (int)Dali::Renderer::Property::DEPTH_TEST_MODE;
26747   jresult = (int)result;
26748   return jresult;
26749 }
26750
26751
26752 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_RENDER_MODE_get() {
26753   int jresult ;
26754   int result;
26755
26756   result = (int)Dali::Renderer::Property::RENDER_MODE;
26757   jresult = (int)result;
26758   return jresult;
26759 }
26760
26761
26762 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_get() {
26763   int jresult ;
26764   int result;
26765
26766   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION;
26767   jresult = (int)result;
26768   return jresult;
26769 }
26770
26771
26772 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_MASK_get() {
26773   int jresult ;
26774   int result;
26775
26776   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_MASK;
26777   jresult = (int)result;
26778   return jresult;
26779 }
26780
26781
26782 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_REFERENCE_get() {
26783   int jresult ;
26784   int result;
26785
26786   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_REFERENCE;
26787   jresult = (int)result;
26788   return jresult;
26789 }
26790
26791
26792 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_MASK_get() {
26793   int jresult ;
26794   int result;
26795
26796   result = (int)Dali::Renderer::Property::STENCIL_MASK;
26797   jresult = (int)result;
26798   return jresult;
26799 }
26800
26801
26802 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_FAIL_get() {
26803   int jresult ;
26804   int result;
26805
26806   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_FAIL;
26807   jresult = (int)result;
26808   return jresult;
26809 }
26810
26811
26812 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_FAIL_get() {
26813   int jresult ;
26814   int result;
26815
26816   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL;
26817   jresult = (int)result;
26818   return jresult;
26819 }
26820
26821
26822 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_PASS_get() {
26823   int jresult ;
26824   int result;
26825
26826   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_PASS;
26827   jresult = (int)result;
26828   return jresult;
26829 }
26830
26831
26832 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer_Property() {
26833   void * jresult ;
26834   Dali::Renderer::Property *result = 0 ;
26835
26836   {
26837     try {
26838       result = (Dali::Renderer::Property *)new Dali::Renderer::Property();
26839     } catch (std::out_of_range& e) {
26840       {
26841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26842       };
26843     } catch (std::exception& e) {
26844       {
26845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26846       };
26847     } catch (Dali::DaliException e) {
26848       {
26849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26850       };
26851     } catch (...) {
26852       {
26853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26854       };
26855     }
26856   }
26857
26858   jresult = (void *)result;
26859   return jresult;
26860 }
26861
26862
26863 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer_Property(void * jarg1) {
26864   Dali::Renderer::Property *arg1 = (Dali::Renderer::Property *) 0 ;
26865
26866   arg1 = (Dali::Renderer::Property *)jarg1;
26867   {
26868     try {
26869       delete arg1;
26870     } catch (std::out_of_range& e) {
26871       {
26872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26873       };
26874     } catch (std::exception& e) {
26875       {
26876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26877       };
26878     } catch (Dali::DaliException e) {
26879       {
26880         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26881       };
26882     } catch (...) {
26883       {
26884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26885       };
26886     }
26887   }
26888
26889 }
26890
26891
26892 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_New(void * jarg1, void * jarg2) {
26893   void * jresult ;
26894   Dali::Geometry *arg1 = 0 ;
26895   Dali::Shader *arg2 = 0 ;
26896   Dali::Renderer result;
26897
26898   arg1 = (Dali::Geometry *)jarg1;
26899   if (!arg1) {
26900     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
26901     return 0;
26902   }
26903   arg2 = (Dali::Shader *)jarg2;
26904   if (!arg2) {
26905     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
26906     return 0;
26907   }
26908   {
26909     try {
26910       result = Dali::Renderer::New(*arg1,*arg2);
26911     } catch (std::out_of_range& e) {
26912       {
26913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26914       };
26915     } catch (std::exception& e) {
26916       {
26917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26918       };
26919     } catch (Dali::DaliException e) {
26920       {
26921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26922       };
26923     } catch (...) {
26924       {
26925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26926       };
26927     }
26928   }
26929
26930   jresult = new Dali::Renderer((const Dali::Renderer &)result);
26931   return jresult;
26932 }
26933
26934
26935 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_0() {
26936   void * jresult ;
26937   Dali::Renderer *result = 0 ;
26938
26939   {
26940     try {
26941       result = (Dali::Renderer *)new Dali::Renderer();
26942     } catch (std::out_of_range& e) {
26943       {
26944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26945       };
26946     } catch (std::exception& e) {
26947       {
26948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26949       };
26950     } catch (Dali::DaliException e) {
26951       {
26952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26953       };
26954     } catch (...) {
26955       {
26956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26957       };
26958     }
26959   }
26960
26961   jresult = (void *)result;
26962   return jresult;
26963 }
26964
26965
26966 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer(void * jarg1) {
26967   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26968
26969   arg1 = (Dali::Renderer *)jarg1;
26970   {
26971     try {
26972       delete arg1;
26973     } catch (std::out_of_range& e) {
26974       {
26975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26976       };
26977     } catch (std::exception& e) {
26978       {
26979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26980       };
26981     } catch (Dali::DaliException e) {
26982       {
26983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26984       };
26985     } catch (...) {
26986       {
26987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26988       };
26989     }
26990   }
26991
26992 }
26993
26994
26995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_1(void * jarg1) {
26996   void * jresult ;
26997   Dali::Renderer *arg1 = 0 ;
26998   Dali::Renderer *result = 0 ;
26999
27000   arg1 = (Dali::Renderer *)jarg1;
27001   if (!arg1) {
27002     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
27003     return 0;
27004   }
27005   {
27006     try {
27007       result = (Dali::Renderer *)new Dali::Renderer((Dali::Renderer const &)*arg1);
27008     } catch (std::out_of_range& e) {
27009       {
27010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27011       };
27012     } catch (std::exception& e) {
27013       {
27014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27015       };
27016     } catch (Dali::DaliException e) {
27017       {
27018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27019       };
27020     } catch (...) {
27021       {
27022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27023       };
27024     }
27025   }
27026
27027   jresult = (void *)result;
27028   return jresult;
27029 }
27030
27031
27032 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_DownCast(void * jarg1) {
27033   void * jresult ;
27034   Dali::BaseHandle arg1 ;
27035   Dali::BaseHandle *argp1 ;
27036   Dali::Renderer result;
27037
27038   argp1 = (Dali::BaseHandle *)jarg1;
27039   if (!argp1) {
27040     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27041     return 0;
27042   }
27043   arg1 = *argp1;
27044   {
27045     try {
27046       result = Dali::Renderer::DownCast(arg1);
27047     } catch (std::out_of_range& e) {
27048       {
27049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27050       };
27051     } catch (std::exception& e) {
27052       {
27053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27054       };
27055     } catch (Dali::DaliException e) {
27056       {
27057         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27058       };
27059     } catch (...) {
27060       {
27061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27062       };
27063     }
27064   }
27065
27066   jresult = new Dali::Renderer((const Dali::Renderer &)result);
27067   return jresult;
27068 }
27069
27070
27071 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_Assign(void * jarg1, void * jarg2) {
27072   void * jresult ;
27073   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27074   Dali::Renderer *arg2 = 0 ;
27075   Dali::Renderer *result = 0 ;
27076
27077   arg1 = (Dali::Renderer *)jarg1;
27078   arg2 = (Dali::Renderer *)jarg2;
27079   if (!arg2) {
27080     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
27081     return 0;
27082   }
27083   {
27084     try {
27085       result = (Dali::Renderer *) &(arg1)->operator =((Dali::Renderer const &)*arg2);
27086     } catch (std::out_of_range& e) {
27087       {
27088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27089       };
27090     } catch (std::exception& e) {
27091       {
27092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27093       };
27094     } catch (Dali::DaliException e) {
27095       {
27096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27097       };
27098     } catch (...) {
27099       {
27100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27101       };
27102     }
27103   }
27104
27105   jresult = (void *)result;
27106   return jresult;
27107 }
27108
27109
27110 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetGeometry(void * jarg1, void * jarg2) {
27111   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27112   Dali::Geometry *arg2 = 0 ;
27113
27114   arg1 = (Dali::Renderer *)jarg1;
27115   arg2 = (Dali::Geometry *)jarg2;
27116   if (!arg2) {
27117     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
27118     return ;
27119   }
27120   {
27121     try {
27122       (arg1)->SetGeometry(*arg2);
27123     } catch (std::out_of_range& e) {
27124       {
27125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27126       };
27127     } catch (std::exception& e) {
27128       {
27129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27130       };
27131     } catch (Dali::DaliException e) {
27132       {
27133         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27134       };
27135     } catch (...) {
27136       {
27137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27138       };
27139     }
27140   }
27141
27142 }
27143
27144
27145 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetGeometry(void * jarg1) {
27146   void * jresult ;
27147   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27148   Dali::Geometry result;
27149
27150   arg1 = (Dali::Renderer *)jarg1;
27151   {
27152     try {
27153       result = ((Dali::Renderer const *)arg1)->GetGeometry();
27154     } catch (std::out_of_range& e) {
27155       {
27156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27157       };
27158     } catch (std::exception& e) {
27159       {
27160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27161       };
27162     } catch (Dali::DaliException e) {
27163       {
27164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27165       };
27166     } catch (...) {
27167       {
27168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27169       };
27170     }
27171   }
27172
27173   jresult = new Dali::Geometry((const Dali::Geometry &)result);
27174   return jresult;
27175 }
27176
27177
27178 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetIndexRange(void * jarg1, int jarg2, int jarg3) {
27179   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27180   int arg2 ;
27181   int arg3 ;
27182
27183   arg1 = (Dali::Renderer *)jarg1;
27184   arg2 = (int)jarg2;
27185   arg3 = (int)jarg3;
27186   {
27187     try {
27188       (arg1)->SetIndexRange(arg2,arg3);
27189     } catch (std::out_of_range& e) {
27190       {
27191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27192       };
27193     } catch (std::exception& e) {
27194       {
27195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27196       };
27197     } catch (Dali::DaliException e) {
27198       {
27199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27200       };
27201     } catch (...) {
27202       {
27203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27204       };
27205     }
27206   }
27207
27208 }
27209
27210
27211 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetTextures(void * jarg1, void * jarg2) {
27212   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27213   Dali::TextureSet *arg2 = 0 ;
27214
27215   arg1 = (Dali::Renderer *)jarg1;
27216   arg2 = (Dali::TextureSet *)jarg2;
27217   if (!arg2) {
27218     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet & type is null", 0);
27219     return ;
27220   }
27221   {
27222     try {
27223       (arg1)->SetTextures(*arg2);
27224     } catch (std::out_of_range& e) {
27225       {
27226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27227       };
27228     } catch (std::exception& e) {
27229       {
27230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27231       };
27232     } catch (Dali::DaliException e) {
27233       {
27234         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27235       };
27236     } catch (...) {
27237       {
27238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27239       };
27240     }
27241   }
27242
27243 }
27244
27245
27246 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetTextures(void * jarg1) {
27247   void * jresult ;
27248   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27249   Dali::TextureSet result;
27250
27251   arg1 = (Dali::Renderer *)jarg1;
27252   {
27253     try {
27254       result = ((Dali::Renderer const *)arg1)->GetTextures();
27255     } catch (std::out_of_range& e) {
27256       {
27257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27258       };
27259     } catch (std::exception& e) {
27260       {
27261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27262       };
27263     } catch (Dali::DaliException e) {
27264       {
27265         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27266       };
27267     } catch (...) {
27268       {
27269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27270       };
27271     }
27272   }
27273
27274   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
27275   return jresult;
27276 }
27277
27278
27279 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetShader(void * jarg1, void * jarg2) {
27280   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27281   Dali::Shader *arg2 = 0 ;
27282
27283   arg1 = (Dali::Renderer *)jarg1;
27284   arg2 = (Dali::Shader *)jarg2;
27285   if (!arg2) {
27286     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
27287     return ;
27288   }
27289   {
27290     try {
27291       (arg1)->SetShader(*arg2);
27292     } catch (std::out_of_range& e) {
27293       {
27294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27295       };
27296     } catch (std::exception& e) {
27297       {
27298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27299       };
27300     } catch (Dali::DaliException e) {
27301       {
27302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27303       };
27304     } catch (...) {
27305       {
27306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27307       };
27308     }
27309   }
27310
27311 }
27312
27313
27314 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetShader(void * jarg1) {
27315   void * jresult ;
27316   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27317   Dali::Shader result;
27318
27319   arg1 = (Dali::Renderer *)jarg1;
27320   {
27321     try {
27322       result = ((Dali::Renderer const *)arg1)->GetShader();
27323     } catch (std::out_of_range& e) {
27324       {
27325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27326       };
27327     } catch (std::exception& e) {
27328       {
27329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27330       };
27331     } catch (Dali::DaliException e) {
27332       {
27333         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27334       };
27335     } catch (...) {
27336       {
27337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27338       };
27339     }
27340   }
27341
27342   jresult = new Dali::Shader((const Dali::Shader &)result);
27343   return jresult;
27344 }
27345
27346
27347 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer_Attachment() {
27348   void * jresult ;
27349   Dali::FrameBuffer::Attachment *result = 0 ;
27350
27351   {
27352     try {
27353       result = (Dali::FrameBuffer::Attachment *)new Dali::FrameBuffer::Attachment();
27354     } catch (std::out_of_range& e) {
27355       {
27356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27357       };
27358     } catch (std::exception& e) {
27359       {
27360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27361       };
27362     } catch (Dali::DaliException e) {
27363       {
27364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27365       };
27366     } catch (...) {
27367       {
27368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27369       };
27370     }
27371   }
27372
27373   jresult = (void *)result;
27374   return jresult;
27375 }
27376
27377
27378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer_Attachment(void * jarg1) {
27379   Dali::FrameBuffer::Attachment *arg1 = (Dali::FrameBuffer::Attachment *) 0 ;
27380
27381   arg1 = (Dali::FrameBuffer::Attachment *)jarg1;
27382   {
27383     try {
27384       delete arg1;
27385     } catch (std::out_of_range& e) {
27386       {
27387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27388       };
27389     } catch (std::exception& e) {
27390       {
27391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27392       };
27393     } catch (Dali::DaliException e) {
27394       {
27395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27396       };
27397     } catch (...) {
27398       {
27399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27400       };
27401     }
27402   }
27403
27404 }
27405
27406
27407 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_New(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
27408   void * jresult ;
27409   unsigned int arg1 ;
27410   unsigned int arg2 ;
27411   unsigned int arg3 ;
27412   Dali::FrameBuffer result;
27413
27414   arg1 = (unsigned int)jarg1;
27415   arg2 = (unsigned int)jarg2;
27416   arg3 = (unsigned int)jarg3;
27417   {
27418     try {
27419       result = Dali::FrameBuffer::New(arg1,arg2,arg3);
27420     } catch (std::out_of_range& e) {
27421       {
27422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27423       };
27424     } catch (std::exception& e) {
27425       {
27426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27427       };
27428     } catch (Dali::DaliException e) {
27429       {
27430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27431       };
27432     } catch (...) {
27433       {
27434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27435       };
27436     }
27437   }
27438
27439   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
27440   return jresult;
27441 }
27442
27443
27444 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_0() {
27445   void * jresult ;
27446   Dali::FrameBuffer *result = 0 ;
27447
27448   {
27449     try {
27450       result = (Dali::FrameBuffer *)new Dali::FrameBuffer();
27451     } catch (std::out_of_range& e) {
27452       {
27453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27454       };
27455     } catch (std::exception& e) {
27456       {
27457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27458       };
27459     } catch (Dali::DaliException e) {
27460       {
27461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27462       };
27463     } catch (...) {
27464       {
27465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27466       };
27467     }
27468   }
27469
27470   jresult = (void *)result;
27471   return jresult;
27472 }
27473
27474
27475 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer(void * jarg1) {
27476   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27477
27478   arg1 = (Dali::FrameBuffer *)jarg1;
27479   {
27480     try {
27481       delete arg1;
27482     } catch (std::out_of_range& e) {
27483       {
27484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27485       };
27486     } catch (std::exception& e) {
27487       {
27488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27489       };
27490     } catch (Dali::DaliException e) {
27491       {
27492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27493       };
27494     } catch (...) {
27495       {
27496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27497       };
27498     }
27499   }
27500
27501 }
27502
27503
27504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_1(void * jarg1) {
27505   void * jresult ;
27506   Dali::FrameBuffer *arg1 = 0 ;
27507   Dali::FrameBuffer *result = 0 ;
27508
27509   arg1 = (Dali::FrameBuffer *)jarg1;
27510   if (!arg1) {
27511     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
27512     return 0;
27513   }
27514   {
27515     try {
27516       result = (Dali::FrameBuffer *)new Dali::FrameBuffer((Dali::FrameBuffer const &)*arg1);
27517     } catch (std::out_of_range& e) {
27518       {
27519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27520       };
27521     } catch (std::exception& e) {
27522       {
27523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27524       };
27525     } catch (Dali::DaliException e) {
27526       {
27527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27528       };
27529     } catch (...) {
27530       {
27531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27532       };
27533     }
27534   }
27535
27536   jresult = (void *)result;
27537   return jresult;
27538 }
27539
27540
27541 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_DownCast(void * jarg1) {
27542   void * jresult ;
27543   Dali::BaseHandle arg1 ;
27544   Dali::BaseHandle *argp1 ;
27545   Dali::FrameBuffer result;
27546
27547   argp1 = (Dali::BaseHandle *)jarg1;
27548   if (!argp1) {
27549     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27550     return 0;
27551   }
27552   arg1 = *argp1;
27553   {
27554     try {
27555       result = Dali::FrameBuffer::DownCast(arg1);
27556     } catch (std::out_of_range& e) {
27557       {
27558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27559       };
27560     } catch (std::exception& e) {
27561       {
27562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27563       };
27564     } catch (Dali::DaliException e) {
27565       {
27566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27567       };
27568     } catch (...) {
27569       {
27570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27571       };
27572     }
27573   }
27574
27575   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
27576   return jresult;
27577 }
27578
27579
27580 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_Assign(void * jarg1, void * jarg2) {
27581   void * jresult ;
27582   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27583   Dali::FrameBuffer *arg2 = 0 ;
27584   Dali::FrameBuffer *result = 0 ;
27585
27586   arg1 = (Dali::FrameBuffer *)jarg1;
27587   arg2 = (Dali::FrameBuffer *)jarg2;
27588   if (!arg2) {
27589     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
27590     return 0;
27591   }
27592   {
27593     try {
27594       result = (Dali::FrameBuffer *) &(arg1)->operator =((Dali::FrameBuffer const &)*arg2);
27595     } catch (std::out_of_range& e) {
27596       {
27597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27598       };
27599     } catch (std::exception& e) {
27600       {
27601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27602       };
27603     } catch (Dali::DaliException e) {
27604       {
27605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27606       };
27607     } catch (...) {
27608       {
27609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27610       };
27611     }
27612   }
27613
27614   jresult = (void *)result;
27615   return jresult;
27616 }
27617
27618
27619 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_0(void * jarg1, void * jarg2) {
27620   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27621   Dali::Texture *arg2 = 0 ;
27622
27623   arg1 = (Dali::FrameBuffer *)jarg1;
27624   arg2 = (Dali::Texture *)jarg2;
27625   if (!arg2) {
27626     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
27627     return ;
27628   }
27629   {
27630     try {
27631       (arg1)->AttachColorTexture(*arg2);
27632     } catch (std::out_of_range& e) {
27633       {
27634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27635       };
27636     } catch (std::exception& e) {
27637       {
27638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27639       };
27640     } catch (Dali::DaliException e) {
27641       {
27642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27643       };
27644     } catch (...) {
27645       {
27646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27647       };
27648     }
27649   }
27650
27651 }
27652
27653
27654 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
27655   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27656   Dali::Texture *arg2 = 0 ;
27657   unsigned int arg3 ;
27658   unsigned int arg4 ;
27659
27660   arg1 = (Dali::FrameBuffer *)jarg1;
27661   arg2 = (Dali::Texture *)jarg2;
27662   if (!arg2) {
27663     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
27664     return ;
27665   }
27666   arg3 = (unsigned int)jarg3;
27667   arg4 = (unsigned int)jarg4;
27668   {
27669     try {
27670       (arg1)->AttachColorTexture(*arg2,arg3,arg4);
27671     } catch (std::out_of_range& e) {
27672       {
27673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27674       };
27675     } catch (std::exception& e) {
27676       {
27677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27678       };
27679     } catch (Dali::DaliException e) {
27680       {
27681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27682       };
27683     } catch (...) {
27684       {
27685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27686       };
27687     }
27688   }
27689
27690 }
27691
27692
27693 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_GetColorTexture(void * jarg1) {
27694   void * jresult ;
27695   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27696   Dali::Texture result;
27697
27698   arg1 = (Dali::FrameBuffer *)jarg1;
27699   {
27700     try {
27701       result = (arg1)->GetColorTexture();
27702     } catch (std::out_of_range& e) {
27703       {
27704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27705       };
27706     } catch (std::exception& e) {
27707       {
27708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27709       };
27710     } catch (Dali::DaliException e) {
27711       {
27712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27713       };
27714     } catch (...) {
27715       {
27716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27717       };
27718     }
27719   }
27720
27721   jresult = new Dali::Texture((const Dali::Texture &)result);
27722   return jresult;
27723 }
27724
27725
27726 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_0() {
27727   void * jresult ;
27728   Dali::RenderTaskList *result = 0 ;
27729
27730   {
27731     try {
27732       result = (Dali::RenderTaskList *)new Dali::RenderTaskList();
27733     } catch (std::out_of_range& e) {
27734       {
27735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27736       };
27737     } catch (std::exception& e) {
27738       {
27739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27740       };
27741     } catch (Dali::DaliException e) {
27742       {
27743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27744       };
27745     } catch (...) {
27746       {
27747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27748       };
27749     }
27750   }
27751
27752   jresult = (void *)result;
27753   return jresult;
27754 }
27755
27756
27757 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_DownCast(void * jarg1) {
27758   void * jresult ;
27759   Dali::BaseHandle arg1 ;
27760   Dali::BaseHandle *argp1 ;
27761   Dali::RenderTaskList result;
27762
27763   argp1 = (Dali::BaseHandle *)jarg1;
27764   if (!argp1) {
27765     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27766     return 0;
27767   }
27768   arg1 = *argp1;
27769   {
27770     try {
27771       result = Dali::RenderTaskList::DownCast(arg1);
27772     } catch (std::out_of_range& e) {
27773       {
27774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27775       };
27776     } catch (std::exception& e) {
27777       {
27778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27779       };
27780     } catch (Dali::DaliException e) {
27781       {
27782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27783       };
27784     } catch (...) {
27785       {
27786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27787       };
27788     }
27789   }
27790
27791   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
27792   return jresult;
27793 }
27794
27795
27796 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskList(void * jarg1) {
27797   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27798
27799   arg1 = (Dali::RenderTaskList *)jarg1;
27800   {
27801     try {
27802       delete arg1;
27803     } catch (std::out_of_range& e) {
27804       {
27805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27806       };
27807     } catch (std::exception& e) {
27808       {
27809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27810       };
27811     } catch (Dali::DaliException e) {
27812       {
27813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27814       };
27815     } catch (...) {
27816       {
27817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27818       };
27819     }
27820   }
27821
27822 }
27823
27824
27825 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_1(void * jarg1) {
27826   void * jresult ;
27827   Dali::RenderTaskList *arg1 = 0 ;
27828   Dali::RenderTaskList *result = 0 ;
27829
27830   arg1 = (Dali::RenderTaskList *)jarg1;
27831   if (!arg1) {
27832     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
27833     return 0;
27834   }
27835   {
27836     try {
27837       result = (Dali::RenderTaskList *)new Dali::RenderTaskList((Dali::RenderTaskList const &)*arg1);
27838     } catch (std::out_of_range& e) {
27839       {
27840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27841       };
27842     } catch (std::exception& e) {
27843       {
27844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27845       };
27846     } catch (Dali::DaliException e) {
27847       {
27848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27849       };
27850     } catch (...) {
27851       {
27852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27853       };
27854     }
27855   }
27856
27857   jresult = (void *)result;
27858   return jresult;
27859 }
27860
27861
27862 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_Assign(void * jarg1, void * jarg2) {
27863   void * jresult ;
27864   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27865   Dali::RenderTaskList *arg2 = 0 ;
27866   Dali::RenderTaskList *result = 0 ;
27867
27868   arg1 = (Dali::RenderTaskList *)jarg1;
27869   arg2 = (Dali::RenderTaskList *)jarg2;
27870   if (!arg2) {
27871     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
27872     return 0;
27873   }
27874   {
27875     try {
27876       result = (Dali::RenderTaskList *) &(arg1)->operator =((Dali::RenderTaskList const &)*arg2);
27877     } catch (std::out_of_range& e) {
27878       {
27879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27880       };
27881     } catch (std::exception& e) {
27882       {
27883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27884       };
27885     } catch (Dali::DaliException e) {
27886       {
27887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27888       };
27889     } catch (...) {
27890       {
27891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27892       };
27893     }
27894   }
27895
27896   jresult = (void *)result;
27897   return jresult;
27898 }
27899
27900
27901 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_CreateTask(void * jarg1) {
27902   void * jresult ;
27903   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27904   Dali::RenderTask result;
27905
27906   arg1 = (Dali::RenderTaskList *)jarg1;
27907   {
27908     try {
27909       result = (arg1)->CreateTask();
27910     } catch (std::out_of_range& e) {
27911       {
27912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27913       };
27914     } catch (std::exception& e) {
27915       {
27916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27917       };
27918     } catch (Dali::DaliException e) {
27919       {
27920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27921       };
27922     } catch (...) {
27923       {
27924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27925       };
27926     }
27927   }
27928
27929   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
27930   return jresult;
27931 }
27932
27933
27934 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTaskList_RemoveTask(void * jarg1, void * jarg2) {
27935   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27936   Dali::RenderTask arg2 ;
27937   Dali::RenderTask *argp2 ;
27938
27939   arg1 = (Dali::RenderTaskList *)jarg1;
27940   argp2 = (Dali::RenderTask *)jarg2;
27941   if (!argp2) {
27942     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RenderTask", 0);
27943     return ;
27944   }
27945   arg2 = *argp2;
27946   {
27947     try {
27948       (arg1)->RemoveTask(arg2);
27949     } catch (std::out_of_range& e) {
27950       {
27951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27952       };
27953     } catch (std::exception& e) {
27954       {
27955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27956       };
27957     } catch (Dali::DaliException e) {
27958       {
27959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27960       };
27961     } catch (...) {
27962       {
27963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27964       };
27965     }
27966   }
27967
27968 }
27969
27970
27971 //// ===============================================end part 1 =================
27972
27973 //// ========================= part 2 ===============================
27974
27975 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTaskCount(void * jarg1) {
27976   unsigned int jresult ;
27977   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27978   unsigned int result;
27979
27980   arg1 = (Dali::RenderTaskList *)jarg1;
27981   {
27982     try {
27983       result = (unsigned int)((Dali::RenderTaskList const *)arg1)->GetTaskCount();
27984     } catch (std::out_of_range& e) {
27985       {
27986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27987       };
27988     } catch (std::exception& e) {
27989       {
27990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27991       };
27992     } catch (Dali::DaliException e) {
27993       {
27994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27995       };
27996     } catch (...) {
27997       {
27998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27999       };
28000     }
28001   }
28002
28003   jresult = result;
28004   return jresult;
28005 }
28006
28007
28008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTask(void * jarg1, unsigned int jarg2) {
28009   void * jresult ;
28010   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
28011   unsigned int arg2 ;
28012   Dali::RenderTask result;
28013
28014   arg1 = (Dali::RenderTaskList *)jarg1;
28015   arg2 = (unsigned int)jarg2;
28016   {
28017     try {
28018       result = ((Dali::RenderTaskList const *)arg1)->GetTask(arg2);
28019     } catch (std::out_of_range& e) {
28020       {
28021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28022       };
28023     } catch (std::exception& e) {
28024       {
28025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28026       };
28027     } catch (Dali::DaliException e) {
28028       {
28029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28030       };
28031     } catch (...) {
28032       {
28033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28034       };
28035     }
28036   }
28037
28038   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
28039   return jresult;
28040 }
28041
28042
28043 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_POSITION_get() {
28044   int jresult ;
28045   int result;
28046
28047   result = (int)Dali::RenderTask::Property::VIEWPORT_POSITION;
28048   jresult = (int)result;
28049   return jresult;
28050 }
28051
28052
28053 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_SIZE_get() {
28054   int jresult ;
28055   int result;
28056
28057   result = (int)Dali::RenderTask::Property::VIEWPORT_SIZE;
28058   jresult = (int)result;
28059   return jresult;
28060 }
28061
28062
28063 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_CLEAR_COLOR_get() {
28064   int jresult ;
28065   int result;
28066
28067   result = (int)Dali::RenderTask::Property::CLEAR_COLOR;
28068   jresult = (int)result;
28069   return jresult;
28070 }
28071
28072
28073 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_REQUIRES_SYNC_get() {
28074   int jresult ;
28075   int result;
28076
28077   result = (int)Dali::RenderTask::Property::REQUIRES_SYNC;
28078   jresult = (int)result;
28079   return jresult;
28080 }
28081
28082
28083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask_Property() {
28084   void * jresult ;
28085   Dali::RenderTask::Property *result = 0 ;
28086
28087   {
28088     try {
28089       result = (Dali::RenderTask::Property *)new Dali::RenderTask::Property();
28090     } catch (std::out_of_range& e) {
28091       {
28092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28093       };
28094     } catch (std::exception& e) {
28095       {
28096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28097       };
28098     } catch (Dali::DaliException e) {
28099       {
28100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28101       };
28102     } catch (...) {
28103       {
28104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28105       };
28106     }
28107   }
28108
28109   jresult = (void *)result;
28110   return jresult;
28111 }
28112
28113
28114 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask_Property(void * jarg1) {
28115   Dali::RenderTask::Property *arg1 = (Dali::RenderTask::Property *) 0 ;
28116
28117   arg1 = (Dali::RenderTask::Property *)jarg1;
28118   {
28119     try {
28120       delete arg1;
28121     } catch (std::out_of_range& e) {
28122       {
28123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28124       };
28125     } catch (std::exception& e) {
28126       {
28127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28128       };
28129     } catch (Dali::DaliException e) {
28130       {
28131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28132       };
28133     } catch (...) {
28134       {
28135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28136       };
28137     }
28138   }
28139
28140 }
28141
28142
28143 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION_get() {
28144   void * jresult ;
28145   bool (*result)(Dali::Vector2 &) = 0 ;
28146
28147   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION;
28148   jresult = (void *)result;
28149   return jresult;
28150 }
28151
28152
28153 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FULLSCREEN_FRAMEBUFFER_FUNCTION_get() {
28154   void * jresult ;
28155   bool (*result)(Dali::Vector2 &) = 0 ;
28156
28157   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::FULLSCREEN_FRAMEBUFFER_FUNCTION;
28158   jresult = (void *)result;
28159   return jresult;
28160 }
28161
28162
28163 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_EXCLUSIVE_get() {
28164   unsigned int jresult ;
28165   bool result;
28166
28167   result = (bool)(bool)Dali::RenderTask::DEFAULT_EXCLUSIVE;
28168   jresult = result;
28169   return jresult;
28170 }
28171
28172
28173 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_INPUT_ENABLED_get() {
28174   unsigned int jresult ;
28175   bool result;
28176
28177   result = (bool)(bool)Dali::RenderTask::DEFAULT_INPUT_ENABLED;
28178   jresult = result;
28179   return jresult;
28180 }
28181
28182
28183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_COLOR_get() {
28184   void * jresult ;
28185   Dali::Vector4 *result = 0 ;
28186
28187   result = (Dali::Vector4 *)&Dali::RenderTask::DEFAULT_CLEAR_COLOR;
28188   jresult = (void *)result;
28189   return jresult;
28190 }
28191
28192
28193 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_ENABLED_get() {
28194   unsigned int jresult ;
28195   bool result;
28196
28197   result = (bool)(bool)Dali::RenderTask::DEFAULT_CLEAR_ENABLED;
28198   jresult = result;
28199   return jresult;
28200 }
28201
28202
28203 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CULL_MODE_get() {
28204   unsigned int jresult ;
28205   bool result;
28206
28207   result = (bool)(bool)Dali::RenderTask::DEFAULT_CULL_MODE;
28208   jresult = result;
28209   return jresult;
28210 }
28211
28212
28213 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_REFRESH_RATE_get() {
28214   unsigned int jresult ;
28215   unsigned int result;
28216
28217   result = (unsigned int)(unsigned int)Dali::RenderTask::DEFAULT_REFRESH_RATE;
28218   jresult = result;
28219   return jresult;
28220 }
28221
28222
28223 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_0() {
28224   void * jresult ;
28225   Dali::RenderTask *result = 0 ;
28226
28227   {
28228     try {
28229       result = (Dali::RenderTask *)new Dali::RenderTask();
28230     } catch (std::out_of_range& e) {
28231       {
28232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28233       };
28234     } catch (std::exception& e) {
28235       {
28236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28237       };
28238     } catch (Dali::DaliException e) {
28239       {
28240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28241       };
28242     } catch (...) {
28243       {
28244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28245       };
28246     }
28247   }
28248
28249   jresult = (void *)result;
28250   return jresult;
28251 }
28252
28253
28254 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DownCast(void * jarg1) {
28255   void * jresult ;
28256   Dali::BaseHandle arg1 ;
28257   Dali::BaseHandle *argp1 ;
28258   Dali::RenderTask result;
28259
28260   argp1 = (Dali::BaseHandle *)jarg1;
28261   if (!argp1) {
28262     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
28263     return 0;
28264   }
28265   arg1 = *argp1;
28266   {
28267     try {
28268       result = Dali::RenderTask::DownCast(arg1);
28269     } catch (std::out_of_range& e) {
28270       {
28271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28272       };
28273     } catch (std::exception& e) {
28274       {
28275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28276       };
28277     } catch (Dali::DaliException e) {
28278       {
28279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28280       };
28281     } catch (...) {
28282       {
28283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28284       };
28285     }
28286   }
28287
28288   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
28289   return jresult;
28290 }
28291
28292
28293 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask(void * jarg1) {
28294   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28295
28296   arg1 = (Dali::RenderTask *)jarg1;
28297   {
28298     try {
28299       delete arg1;
28300     } catch (std::out_of_range& e) {
28301       {
28302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28303       };
28304     } catch (std::exception& e) {
28305       {
28306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28307       };
28308     } catch (Dali::DaliException e) {
28309       {
28310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28311       };
28312     } catch (...) {
28313       {
28314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28315       };
28316     }
28317   }
28318
28319 }
28320
28321
28322 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_1(void * jarg1) {
28323   void * jresult ;
28324   Dali::RenderTask *arg1 = 0 ;
28325   Dali::RenderTask *result = 0 ;
28326
28327   arg1 = (Dali::RenderTask *)jarg1;
28328   if (!arg1) {
28329     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
28330     return 0;
28331   }
28332   {
28333     try {
28334       result = (Dali::RenderTask *)new Dali::RenderTask((Dali::RenderTask const &)*arg1);
28335     } catch (std::out_of_range& e) {
28336       {
28337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28338       };
28339     } catch (std::exception& e) {
28340       {
28341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28342       };
28343     } catch (Dali::DaliException e) {
28344       {
28345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28346       };
28347     } catch (...) {
28348       {
28349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28350       };
28351     }
28352   }
28353
28354   jresult = (void *)result;
28355   return jresult;
28356 }
28357
28358
28359 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_Assign(void * jarg1, void * jarg2) {
28360   void * jresult ;
28361   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28362   Dali::RenderTask *arg2 = 0 ;
28363   Dali::RenderTask *result = 0 ;
28364
28365   arg1 = (Dali::RenderTask *)jarg1;
28366   arg2 = (Dali::RenderTask *)jarg2;
28367   if (!arg2) {
28368     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
28369     return 0;
28370   }
28371   {
28372     try {
28373       result = (Dali::RenderTask *) &(arg1)->operator =((Dali::RenderTask const &)*arg2);
28374     } catch (std::out_of_range& e) {
28375       {
28376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28377       };
28378     } catch (std::exception& e) {
28379       {
28380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28381       };
28382     } catch (Dali::DaliException e) {
28383       {
28384         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28385       };
28386     } catch (...) {
28387       {
28388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28389       };
28390     }
28391   }
28392
28393   jresult = (void *)result;
28394   return jresult;
28395 }
28396
28397
28398 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetSourceActor(void * jarg1, void * jarg2) {
28399   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28400   Dali::Actor arg2 ;
28401   Dali::Actor *argp2 ;
28402
28403   arg1 = (Dali::RenderTask *)jarg1;
28404   argp2 = (Dali::Actor *)jarg2;
28405   if (!argp2) {
28406     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28407     return ;
28408   }
28409   arg2 = *argp2;
28410   {
28411     try {
28412       (arg1)->SetSourceActor(arg2);
28413     } catch (std::out_of_range& e) {
28414       {
28415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28416       };
28417     } catch (std::exception& e) {
28418       {
28419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28420       };
28421     } catch (Dali::DaliException e) {
28422       {
28423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28424       };
28425     } catch (...) {
28426       {
28427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28428       };
28429     }
28430   }
28431
28432 }
28433
28434
28435 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetSourceActor(void * jarg1) {
28436   void * jresult ;
28437   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28438   Dali::Actor result;
28439
28440   arg1 = (Dali::RenderTask *)jarg1;
28441   {
28442     try {
28443       result = ((Dali::RenderTask const *)arg1)->GetSourceActor();
28444     } catch (std::out_of_range& e) {
28445       {
28446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28447       };
28448     } catch (std::exception& e) {
28449       {
28450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28451       };
28452     } catch (Dali::DaliException e) {
28453       {
28454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28455       };
28456     } catch (...) {
28457       {
28458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28459       };
28460     }
28461   }
28462
28463   jresult = new Dali::Actor((const Dali::Actor &)result);
28464   return jresult;
28465 }
28466
28467
28468 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetExclusive(void * jarg1, unsigned int jarg2) {
28469   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28470   bool arg2 ;
28471
28472   arg1 = (Dali::RenderTask *)jarg1;
28473   arg2 = jarg2 ? true : false;
28474   {
28475     try {
28476       (arg1)->SetExclusive(arg2);
28477     } catch (std::out_of_range& e) {
28478       {
28479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28480       };
28481     } catch (std::exception& e) {
28482       {
28483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28484       };
28485     } catch (Dali::DaliException e) {
28486       {
28487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28488       };
28489     } catch (...) {
28490       {
28491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28492       };
28493     }
28494   }
28495
28496 }
28497
28498
28499 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_IsExclusive(void * jarg1) {
28500   unsigned int jresult ;
28501   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28502   bool result;
28503
28504   arg1 = (Dali::RenderTask *)jarg1;
28505   {
28506     try {
28507       result = (bool)((Dali::RenderTask const *)arg1)->IsExclusive();
28508     } catch (std::out_of_range& e) {
28509       {
28510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28511       };
28512     } catch (std::exception& e) {
28513       {
28514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28515       };
28516     } catch (Dali::DaliException e) {
28517       {
28518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28519       };
28520     } catch (...) {
28521       {
28522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28523       };
28524     }
28525   }
28526
28527   jresult = result;
28528   return jresult;
28529 }
28530
28531
28532 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetInputEnabled(void * jarg1, unsigned int jarg2) {
28533   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28534   bool arg2 ;
28535
28536   arg1 = (Dali::RenderTask *)jarg1;
28537   arg2 = jarg2 ? true : false;
28538   {
28539     try {
28540       (arg1)->SetInputEnabled(arg2);
28541     } catch (std::out_of_range& e) {
28542       {
28543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28544       };
28545     } catch (std::exception& e) {
28546       {
28547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28548       };
28549     } catch (Dali::DaliException e) {
28550       {
28551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28552       };
28553     } catch (...) {
28554       {
28555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28556       };
28557     }
28558   }
28559
28560 }
28561
28562
28563 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetInputEnabled(void * jarg1) {
28564   unsigned int jresult ;
28565   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28566   bool result;
28567
28568   arg1 = (Dali::RenderTask *)jarg1;
28569   {
28570     try {
28571       result = (bool)((Dali::RenderTask const *)arg1)->GetInputEnabled();
28572     } catch (std::out_of_range& e) {
28573       {
28574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28575       };
28576     } catch (std::exception& e) {
28577       {
28578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28579       };
28580     } catch (Dali::DaliException e) {
28581       {
28582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28583       };
28584     } catch (...) {
28585       {
28586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28587       };
28588     }
28589   }
28590
28591   jresult = result;
28592   return jresult;
28593 }
28594
28595
28596 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCameraActor(void * jarg1, void * jarg2) {
28597   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28598   Dali::CameraActor arg2 ;
28599   Dali::CameraActor *argp2 ;
28600
28601   arg1 = (Dali::RenderTask *)jarg1;
28602   argp2 = (Dali::CameraActor *)jarg2;
28603   if (!argp2) {
28604     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::CameraActor", 0);
28605     return ;
28606   }
28607   arg2 = *argp2;
28608   {
28609     try {
28610       (arg1)->SetCameraActor(arg2);
28611     } catch (std::out_of_range& e) {
28612       {
28613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28614       };
28615     } catch (std::exception& e) {
28616       {
28617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28618       };
28619     } catch (Dali::DaliException e) {
28620       {
28621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28622       };
28623     } catch (...) {
28624       {
28625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28626       };
28627     }
28628   }
28629
28630 }
28631
28632
28633 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCameraActor(void * jarg1) {
28634   void * jresult ;
28635   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28636   Dali::CameraActor result;
28637
28638   arg1 = (Dali::RenderTask *)jarg1;
28639   {
28640     try {
28641       result = ((Dali::RenderTask const *)arg1)->GetCameraActor();
28642     } catch (std::out_of_range& e) {
28643       {
28644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28645       };
28646     } catch (std::exception& e) {
28647       {
28648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28649       };
28650     } catch (Dali::DaliException e) {
28651       {
28652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28653       };
28654     } catch (...) {
28655       {
28656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28657       };
28658     }
28659   }
28660
28661   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
28662   return jresult;
28663 }
28664
28665
28666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetTargetFrameBuffer(void * jarg1, void * jarg2) {
28667   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28668   Dali::FrameBufferImage arg2 ;
28669   Dali::FrameBufferImage *argp2 ;
28670
28671   arg1 = (Dali::RenderTask *)jarg1;
28672   argp2 = (Dali::FrameBufferImage *)jarg2;
28673   if (!argp2) {
28674     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
28675     return ;
28676   }
28677   arg2 = *argp2;
28678   {
28679     try {
28680       (arg1)->SetTargetFrameBuffer(arg2);
28681     } catch (std::out_of_range& e) {
28682       {
28683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28684       };
28685     } catch (std::exception& e) {
28686       {
28687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28688       };
28689     } catch (Dali::DaliException e) {
28690       {
28691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28692       };
28693     } catch (...) {
28694       {
28695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28696       };
28697     }
28698   }
28699
28700 }
28701
28702
28703 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetTargetFrameBuffer(void * jarg1) {
28704   void * jresult ;
28705   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28706   Dali::FrameBufferImage result;
28707
28708   arg1 = (Dali::RenderTask *)jarg1;
28709   {
28710     try {
28711       result = ((Dali::RenderTask const *)arg1)->GetTargetFrameBuffer();
28712     } catch (std::out_of_range& e) {
28713       {
28714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28715       };
28716     } catch (std::exception& e) {
28717       {
28718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28719       };
28720     } catch (Dali::DaliException e) {
28721       {
28722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28723       };
28724     } catch (...) {
28725       {
28726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28727       };
28728     }
28729   }
28730
28731   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
28732   return jresult;
28733 }
28734
28735
28736 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetFrameBuffer(void * jarg1, void * jarg2) {
28737   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28738   Dali::FrameBuffer arg2 ;
28739   Dali::FrameBuffer *argp2 ;
28740
28741   arg1 = (Dali::RenderTask *)jarg1;
28742   argp2 = (Dali::FrameBuffer *)jarg2;
28743   if (!argp2) {
28744     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
28745     return ;
28746   }
28747   arg2 = *argp2;
28748   {
28749     try {
28750       (arg1)->SetFrameBuffer(arg2);
28751     } catch (std::out_of_range& e) {
28752       {
28753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28754       };
28755     } catch (std::exception& e) {
28756       {
28757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28758       };
28759     } catch (Dali::DaliException e) {
28760       {
28761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28762       };
28763     } catch (...) {
28764       {
28765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28766       };
28767     }
28768   }
28769
28770 }
28771
28772
28773 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetFrameBuffer(void * jarg1) {
28774   void * jresult ;
28775   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28776   Dali::FrameBuffer result;
28777
28778   arg1 = (Dali::RenderTask *)jarg1;
28779   {
28780     try {
28781       result = ((Dali::RenderTask const *)arg1)->GetFrameBuffer();
28782     } catch (std::out_of_range& e) {
28783       {
28784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28785       };
28786     } catch (std::exception& e) {
28787       {
28788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28789       };
28790     } catch (Dali::DaliException e) {
28791       {
28792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28793       };
28794     } catch (...) {
28795       {
28796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28797       };
28798     }
28799   }
28800
28801   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
28802   return jresult;
28803 }
28804
28805
28806 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferFunction(void * jarg1, void * jarg2) {
28807   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28808   Dali::RenderTask::ScreenToFrameBufferFunction arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction) 0 ;
28809
28810   arg1 = (Dali::RenderTask *)jarg1;
28811   arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction)jarg2;
28812   {
28813     try {
28814       (arg1)->SetScreenToFrameBufferFunction(arg2);
28815     } catch (std::out_of_range& e) {
28816       {
28817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28818       };
28819     } catch (std::exception& e) {
28820       {
28821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28822       };
28823     } catch (Dali::DaliException e) {
28824       {
28825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28826       };
28827     } catch (...) {
28828       {
28829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28830       };
28831     }
28832   }
28833
28834 }
28835
28836
28837 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferFunction(void * jarg1) {
28838   void * jresult ;
28839   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28840   Dali::RenderTask::ScreenToFrameBufferFunction result;
28841
28842   arg1 = (Dali::RenderTask *)jarg1;
28843   {
28844     try {
28845       result = (Dali::RenderTask::ScreenToFrameBufferFunction)((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferFunction();
28846     } catch (std::out_of_range& e) {
28847       {
28848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28849       };
28850     } catch (std::exception& e) {
28851       {
28852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28853       };
28854     } catch (Dali::DaliException e) {
28855       {
28856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28857       };
28858     } catch (...) {
28859       {
28860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28861       };
28862     }
28863   }
28864
28865   jresult = (void *)result;
28866   return jresult;
28867 }
28868
28869
28870 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferMappingActor(void * jarg1, void * jarg2) {
28871   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28872   Dali::Actor arg2 ;
28873   Dali::Actor *argp2 ;
28874
28875   arg1 = (Dali::RenderTask *)jarg1;
28876   argp2 = (Dali::Actor *)jarg2;
28877   if (!argp2) {
28878     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28879     return ;
28880   }
28881   arg2 = *argp2;
28882   {
28883     try {
28884       (arg1)->SetScreenToFrameBufferMappingActor(arg2);
28885     } catch (std::out_of_range& e) {
28886       {
28887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28888       };
28889     } catch (std::exception& e) {
28890       {
28891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28892       };
28893     } catch (Dali::DaliException e) {
28894       {
28895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28896       };
28897     } catch (...) {
28898       {
28899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28900       };
28901     }
28902   }
28903
28904 }
28905
28906
28907 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferMappingActor(void * jarg1) {
28908   void * jresult ;
28909   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28910   Dali::Actor result;
28911
28912   arg1 = (Dali::RenderTask *)jarg1;
28913   {
28914     try {
28915       result = ((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferMappingActor();
28916     } catch (std::out_of_range& e) {
28917       {
28918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28919       };
28920     } catch (std::exception& e) {
28921       {
28922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28923       };
28924     } catch (Dali::DaliException e) {
28925       {
28926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28927       };
28928     } catch (...) {
28929       {
28930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28931       };
28932     }
28933   }
28934
28935   jresult = new Dali::Actor((const Dali::Actor &)result);
28936   return jresult;
28937 }
28938
28939
28940 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportPosition(void * jarg1, void * jarg2) {
28941   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28942   Dali::Vector2 arg2 ;
28943   Dali::Vector2 *argp2 ;
28944
28945   arg1 = (Dali::RenderTask *)jarg1;
28946   argp2 = (Dali::Vector2 *)jarg2;
28947   if (!argp2) {
28948     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
28949     return ;
28950   }
28951   arg2 = *argp2;
28952   {
28953     try {
28954       (arg1)->SetViewportPosition(arg2);
28955     } catch (std::out_of_range& e) {
28956       {
28957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28958       };
28959     } catch (std::exception& e) {
28960       {
28961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28962       };
28963     } catch (Dali::DaliException e) {
28964       {
28965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28966       };
28967     } catch (...) {
28968       {
28969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28970       };
28971     }
28972   }
28973
28974 }
28975
28976
28977 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportPosition(void * jarg1) {
28978   void * jresult ;
28979   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28980   Dali::Vector2 result;
28981
28982   arg1 = (Dali::RenderTask *)jarg1;
28983   {
28984     try {
28985       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportPosition();
28986     } catch (std::out_of_range& e) {
28987       {
28988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28989       };
28990     } catch (std::exception& e) {
28991       {
28992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28993       };
28994     } catch (Dali::DaliException e) {
28995       {
28996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28997       };
28998     } catch (...) {
28999       {
29000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29001       };
29002     }
29003   }
29004
29005   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
29006   return jresult;
29007 }
29008
29009
29010 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportSize(void * jarg1, void * jarg2) {
29011   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29012   Dali::Vector2 arg2 ;
29013   Dali::Vector2 *argp2 ;
29014
29015   arg1 = (Dali::RenderTask *)jarg1;
29016   argp2 = (Dali::Vector2 *)jarg2;
29017   if (!argp2) {
29018     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
29019     return ;
29020   }
29021   arg2 = *argp2;
29022   {
29023     try {
29024       (arg1)->SetViewportSize(arg2);
29025     } catch (std::out_of_range& e) {
29026       {
29027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29028       };
29029     } catch (std::exception& e) {
29030       {
29031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29032       };
29033     } catch (Dali::DaliException e) {
29034       {
29035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29036       };
29037     } catch (...) {
29038       {
29039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29040       };
29041     }
29042   }
29043
29044 }
29045
29046
29047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportSize(void * jarg1) {
29048   void * jresult ;
29049   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29050   Dali::Vector2 result;
29051
29052   arg1 = (Dali::RenderTask *)jarg1;
29053   {
29054     try {
29055       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportSize();
29056     } catch (std::out_of_range& e) {
29057       {
29058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29059       };
29060     } catch (std::exception& e) {
29061       {
29062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29063       };
29064     } catch (Dali::DaliException e) {
29065       {
29066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29067       };
29068     } catch (...) {
29069       {
29070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29071       };
29072     }
29073   }
29074
29075   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
29076   return jresult;
29077 }
29078
29079
29080 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewport(void * jarg1, void * jarg2) {
29081   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29082   Dali::Viewport arg2 ;
29083   Dali::Viewport *argp2 ;
29084
29085   arg1 = (Dali::RenderTask *)jarg1;
29086   argp2 = (Dali::Viewport *)jarg2;
29087   if (!argp2) {
29088     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Viewport", 0);
29089     return ;
29090   }
29091   arg2 = *argp2;
29092   {
29093     try {
29094       (arg1)->SetViewport(arg2);
29095     } catch (std::out_of_range& e) {
29096       {
29097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29098       };
29099     } catch (std::exception& e) {
29100       {
29101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29102       };
29103     } catch (Dali::DaliException e) {
29104       {
29105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29106       };
29107     } catch (...) {
29108       {
29109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29110       };
29111     }
29112   }
29113
29114 }
29115
29116
29117 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetViewport(void * jarg1) {
29118   void * jresult ;
29119   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29120   Dali::Viewport result;
29121
29122   arg1 = (Dali::RenderTask *)jarg1;
29123   {
29124     try {
29125       result = ((Dali::RenderTask const *)arg1)->GetViewport();
29126     } catch (std::out_of_range& e) {
29127       {
29128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29129       };
29130     } catch (std::exception& e) {
29131       {
29132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29133       };
29134     } catch (Dali::DaliException e) {
29135       {
29136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29137       };
29138     } catch (...) {
29139       {
29140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29141       };
29142     }
29143   }
29144
29145   jresult = new Dali::Viewport((const Dali::Viewport &)result);
29146   return jresult;
29147 }
29148
29149
29150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearColor(void * jarg1, void * jarg2) {
29151   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29152   Dali::Vector4 *arg2 = 0 ;
29153
29154   arg1 = (Dali::RenderTask *)jarg1;
29155   arg2 = (Dali::Vector4 *)jarg2;
29156   if (!arg2) {
29157     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
29158     return ;
29159   }
29160   {
29161     try {
29162       (arg1)->SetClearColor((Dali::Vector4 const &)*arg2);
29163     } catch (std::out_of_range& e) {
29164       {
29165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29166       };
29167     } catch (std::exception& e) {
29168       {
29169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29170       };
29171     } catch (Dali::DaliException e) {
29172       {
29173         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29174       };
29175     } catch (...) {
29176       {
29177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29178       };
29179     }
29180   }
29181
29182 }
29183
29184
29185 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetClearColor(void * jarg1) {
29186   void * jresult ;
29187   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29188   Dali::Vector4 result;
29189
29190   arg1 = (Dali::RenderTask *)jarg1;
29191   {
29192     try {
29193       result = ((Dali::RenderTask const *)arg1)->GetClearColor();
29194     } catch (std::out_of_range& e) {
29195       {
29196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29197       };
29198     } catch (std::exception& e) {
29199       {
29200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29201       };
29202     } catch (Dali::DaliException e) {
29203       {
29204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29205       };
29206     } catch (...) {
29207       {
29208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29209       };
29210     }
29211   }
29212
29213   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
29214   return jresult;
29215 }
29216
29217
29218 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearEnabled(void * jarg1, unsigned int jarg2) {
29219   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29220   bool arg2 ;
29221
29222   arg1 = (Dali::RenderTask *)jarg1;
29223   arg2 = jarg2 ? true : false;
29224   {
29225     try {
29226       (arg1)->SetClearEnabled(arg2);
29227     } catch (std::out_of_range& e) {
29228       {
29229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29230       };
29231     } catch (std::exception& e) {
29232       {
29233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29234       };
29235     } catch (Dali::DaliException e) {
29236       {
29237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29238       };
29239     } catch (...) {
29240       {
29241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29242       };
29243     }
29244   }
29245
29246 }
29247
29248
29249 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetClearEnabled(void * jarg1) {
29250   unsigned int jresult ;
29251   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29252   bool result;
29253
29254   arg1 = (Dali::RenderTask *)jarg1;
29255   {
29256     try {
29257       result = (bool)((Dali::RenderTask const *)arg1)->GetClearEnabled();
29258     } catch (std::out_of_range& e) {
29259       {
29260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29261       };
29262     } catch (std::exception& e) {
29263       {
29264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29265       };
29266     } catch (Dali::DaliException e) {
29267       {
29268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29269       };
29270     } catch (...) {
29271       {
29272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29273       };
29274     }
29275   }
29276
29277   jresult = result;
29278   return jresult;
29279 }
29280
29281
29282 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCullMode(void * jarg1, unsigned int jarg2) {
29283   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29284   bool arg2 ;
29285
29286   arg1 = (Dali::RenderTask *)jarg1;
29287   arg2 = jarg2 ? true : false;
29288   {
29289     try {
29290       (arg1)->SetCullMode(arg2);
29291     } catch (std::out_of_range& e) {
29292       {
29293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29294       };
29295     } catch (std::exception& e) {
29296       {
29297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29298       };
29299     } catch (Dali::DaliException e) {
29300       {
29301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29302       };
29303     } catch (...) {
29304       {
29305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29306       };
29307     }
29308   }
29309
29310 }
29311
29312
29313 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetCullMode(void * jarg1) {
29314   unsigned int jresult ;
29315   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29316   bool result;
29317
29318   arg1 = (Dali::RenderTask *)jarg1;
29319   {
29320     try {
29321       result = (bool)((Dali::RenderTask const *)arg1)->GetCullMode();
29322     } catch (std::out_of_range& e) {
29323       {
29324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29325       };
29326     } catch (std::exception& e) {
29327       {
29328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29329       };
29330     } catch (Dali::DaliException e) {
29331       {
29332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29333       };
29334     } catch (...) {
29335       {
29336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29337       };
29338     }
29339   }
29340
29341   jresult = result;
29342   return jresult;
29343 }
29344
29345
29346 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetRefreshRate(void * jarg1, unsigned int jarg2) {
29347   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29348   unsigned int arg2 ;
29349
29350   arg1 = (Dali::RenderTask *)jarg1;
29351   arg2 = (unsigned int)jarg2;
29352   {
29353     try {
29354       (arg1)->SetRefreshRate(arg2);
29355     } catch (std::out_of_range& e) {
29356       {
29357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29358       };
29359     } catch (std::exception& e) {
29360       {
29361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29362       };
29363     } catch (Dali::DaliException e) {
29364       {
29365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29366       };
29367     } catch (...) {
29368       {
29369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29370       };
29371     }
29372   }
29373
29374 }
29375
29376
29377 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetRefreshRate(void * jarg1) {
29378   unsigned int jresult ;
29379   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29380   unsigned int result;
29381
29382   arg1 = (Dali::RenderTask *)jarg1;
29383   {
29384     try {
29385       result = (unsigned int)((Dali::RenderTask const *)arg1)->GetRefreshRate();
29386     } catch (std::out_of_range& e) {
29387       {
29388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29389       };
29390     } catch (std::exception& e) {
29391       {
29392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29393       };
29394     } catch (Dali::DaliException e) {
29395       {
29396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29397       };
29398     } catch (...) {
29399       {
29400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29401       };
29402     }
29403   }
29404
29405   jresult = result;
29406   return jresult;
29407 }
29408
29409
29410 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_WorldToViewport(void * jarg1, void * jarg2, float * jarg3, float * jarg4) {
29411   unsigned int jresult ;
29412   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29413   Dali::Vector3 *arg2 = 0 ;
29414   float *arg3 = 0 ;
29415   float *arg4 = 0 ;
29416   bool result;
29417
29418   arg1 = (Dali::RenderTask *)jarg1;
29419   arg2 = (Dali::Vector3 *)jarg2;
29420   if (!arg2) {
29421     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29422     return 0;
29423   }
29424   arg3 = (float *)jarg3;
29425   arg4 = (float *)jarg4;
29426   {
29427     try {
29428       result = (bool)((Dali::RenderTask const *)arg1)->WorldToViewport((Dali::Vector3 const &)*arg2,*arg3,*arg4);
29429     } catch (std::out_of_range& e) {
29430       {
29431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29432       };
29433     } catch (std::exception& e) {
29434       {
29435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29436       };
29437     } catch (Dali::DaliException e) {
29438       {
29439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29440       };
29441     } catch (...) {
29442       {
29443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29444       };
29445     }
29446   }
29447
29448   jresult = result;
29449   return jresult;
29450 }
29451
29452
29453 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_ViewportToLocal(void * jarg1, void * jarg2, float jarg3, float jarg4, float * jarg5, float * jarg6) {
29454   unsigned int jresult ;
29455   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29456   Dali::Actor arg2 ;
29457   float arg3 ;
29458   float arg4 ;
29459   float *arg5 = 0 ;
29460   float *arg6 = 0 ;
29461   Dali::Actor *argp2 ;
29462   bool result;
29463
29464   arg1 = (Dali::RenderTask *)jarg1;
29465   argp2 = (Dali::Actor *)jarg2;
29466   if (!argp2) {
29467     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
29468     return 0;
29469   }
29470   arg2 = *argp2;
29471   arg3 = (float)jarg3;
29472   arg4 = (float)jarg4;
29473   arg5 = (float *)jarg5;
29474   arg6 = (float *)jarg6;
29475   {
29476     try {
29477       result = (bool)((Dali::RenderTask const *)arg1)->ViewportToLocal(arg2,arg3,arg4,*arg5,*arg6);
29478     } catch (std::out_of_range& e) {
29479       {
29480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29481       };
29482     } catch (std::exception& e) {
29483       {
29484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29485       };
29486     } catch (Dali::DaliException e) {
29487       {
29488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29489       };
29490     } catch (...) {
29491       {
29492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29493       };
29494     }
29495   }
29496
29497   jresult = result;
29498   return jresult;
29499 }
29500
29501
29502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FinishedSignal(void * jarg1) {
29503   void * jresult ;
29504   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29505   Dali::RenderTask::RenderTaskSignalType *result = 0 ;
29506
29507   arg1 = (Dali::RenderTask *)jarg1;
29508   {
29509     try {
29510       result = (Dali::RenderTask::RenderTaskSignalType *) &(arg1)->FinishedSignal();
29511     } catch (std::out_of_range& e) {
29512       {
29513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29514       };
29515     } catch (std::exception& e) {
29516       {
29517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29518       };
29519     } catch (Dali::DaliException e) {
29520       {
29521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29522       };
29523     } catch (...) {
29524       {
29525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29526       };
29527     }
29528   }
29529
29530   jresult = (void *)result;
29531   return jresult;
29532 }
29533
29534
29535 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_0(int jarg1, int jarg2, float jarg3, float jarg4) {
29536   void * jresult ;
29537   int arg1 ;
29538   Dali::TouchPoint::State arg2 ;
29539   float arg3 ;
29540   float arg4 ;
29541   Dali::TouchPoint *result = 0 ;
29542
29543   arg1 = (int)jarg1;
29544   arg2 = (Dali::TouchPoint::State)jarg2;
29545   arg3 = (float)jarg3;
29546   arg4 = (float)jarg4;
29547   {
29548     try {
29549       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4);
29550     } catch (std::out_of_range& e) {
29551       {
29552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29553       };
29554     } catch (std::exception& e) {
29555       {
29556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29557       };
29558     } catch (Dali::DaliException e) {
29559       {
29560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29561       };
29562     } catch (...) {
29563       {
29564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29565       };
29566     }
29567   }
29568
29569   jresult = (void *)result;
29570   return jresult;
29571 }
29572
29573
29574 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_1(int jarg1, int jarg2, float jarg3, float jarg4, float jarg5, float jarg6) {
29575   void * jresult ;
29576   int arg1 ;
29577   Dali::TouchPoint::State arg2 ;
29578   float arg3 ;
29579   float arg4 ;
29580   float arg5 ;
29581   float arg6 ;
29582   Dali::TouchPoint *result = 0 ;
29583
29584   arg1 = (int)jarg1;
29585   arg2 = (Dali::TouchPoint::State)jarg2;
29586   arg3 = (float)jarg3;
29587   arg4 = (float)jarg4;
29588   arg5 = (float)jarg5;
29589   arg6 = (float)jarg6;
29590   {
29591     try {
29592       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4,arg5,arg6);
29593     } catch (std::out_of_range& e) {
29594       {
29595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29596       };
29597     } catch (std::exception& e) {
29598       {
29599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29600       };
29601     } catch (Dali::DaliException e) {
29602       {
29603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29604       };
29605     } catch (...) {
29606       {
29607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29608       };
29609     }
29610   }
29611
29612   jresult = (void *)result;
29613   return jresult;
29614 }
29615
29616
29617 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPoint(void * jarg1) {
29618   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29619
29620   arg1 = (Dali::TouchPoint *)jarg1;
29621   {
29622     try {
29623       delete arg1;
29624     } catch (std::out_of_range& e) {
29625       {
29626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29627       };
29628     } catch (std::exception& e) {
29629       {
29630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29631       };
29632     } catch (Dali::DaliException e) {
29633       {
29634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29635       };
29636     } catch (...) {
29637       {
29638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29639       };
29640     }
29641   }
29642
29643 }
29644
29645
29646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_set(void * jarg1, int jarg2) {
29647   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29648   int arg2 ;
29649
29650   arg1 = (Dali::TouchPoint *)jarg1;
29651   arg2 = (int)jarg2;
29652   if (arg1) (arg1)->deviceId = arg2;
29653 }
29654
29655
29656 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_get(void * jarg1) {
29657   int jresult ;
29658   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29659   int result;
29660
29661   arg1 = (Dali::TouchPoint *)jarg1;
29662   result = (int) ((arg1)->deviceId);
29663   jresult = result;
29664   return jresult;
29665 }
29666
29667
29668 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_state_set(void * jarg1, int jarg2) {
29669   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29670   Dali::TouchPoint::State arg2 ;
29671
29672   arg1 = (Dali::TouchPoint *)jarg1;
29673   arg2 = (Dali::TouchPoint::State)jarg2;
29674   if (arg1) (arg1)->state = arg2;
29675 }
29676
29677
29678 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_state_get(void * jarg1) {
29679   int jresult ;
29680   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29681   Dali::TouchPoint::State result;
29682
29683   arg1 = (Dali::TouchPoint *)jarg1;
29684   result = (Dali::TouchPoint::State) ((arg1)->state);
29685   jresult = (int)result;
29686   return jresult;
29687 }
29688
29689
29690 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_set(void * jarg1, void * jarg2) {
29691   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29692   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
29693
29694   arg1 = (Dali::TouchPoint *)jarg1;
29695   arg2 = (Dali::Actor *)jarg2;
29696   if (arg1) (arg1)->hitActor = *arg2;
29697 }
29698
29699
29700 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_get(void * jarg1) {
29701   void * jresult ;
29702   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29703   Dali::Actor *result = 0 ;
29704
29705   arg1 = (Dali::TouchPoint *)jarg1;
29706   result = (Dali::Actor *)& ((arg1)->hitActor);
29707   jresult = (void *)result;
29708   return jresult;
29709 }
29710
29711
29712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_local_set(void * jarg1, void * jarg2) {
29713   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29714   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
29715
29716   arg1 = (Dali::TouchPoint *)jarg1;
29717   arg2 = (Dali::Vector2 *)jarg2;
29718   if (arg1) (arg1)->local = *arg2;
29719 }
29720
29721
29722 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_local_get(void * jarg1) {
29723   void * jresult ;
29724   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29725   Dali::Vector2 *result = 0 ;
29726
29727   arg1 = (Dali::TouchPoint *)jarg1;
29728   result = (Dali::Vector2 *)& ((arg1)->local);
29729   jresult = (void *)result;
29730   return jresult;
29731 }
29732
29733
29734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_screen_set(void * jarg1, void * jarg2) {
29735   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29736   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
29737
29738   arg1 = (Dali::TouchPoint *)jarg1;
29739   arg2 = (Dali::Vector2 *)jarg2;
29740   if (arg1) (arg1)->screen = *arg2;
29741 }
29742
29743
29744 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_screen_get(void * jarg1) {
29745   void * jresult ;
29746   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29747   Dali::Vector2 *result = 0 ;
29748
29749   arg1 = (Dali::TouchPoint *)jarg1;
29750   result = (Dali::Vector2 *)& ((arg1)->screen);
29751   jresult = (void *)result;
29752   return jresult;
29753 }
29754
29755
29756 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_0() {
29757   void * jresult ;
29758   Dali::TouchData *result = 0 ;
29759
29760   {
29761     try {
29762       result = (Dali::TouchData *)new Dali::TouchData();
29763     } catch (std::out_of_range& e) {
29764       {
29765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29766       };
29767     } catch (std::exception& e) {
29768       {
29769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29770       };
29771     } catch (Dali::DaliException e) {
29772       {
29773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29774       };
29775     } catch (...) {
29776       {
29777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29778       };
29779     }
29780   }
29781
29782   jresult = (void *)result;
29783   return jresult;
29784 }
29785
29786
29787 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_1(void * jarg1) {
29788   void * jresult ;
29789   Dali::TouchData *arg1 = 0 ;
29790   Dali::TouchData *result = 0 ;
29791
29792   arg1 = (Dali::TouchData *)jarg1;
29793   if (!arg1) {
29794     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
29795     return 0;
29796   }
29797   {
29798     try {
29799       result = (Dali::TouchData *)new Dali::TouchData((Dali::TouchData const &)*arg1);
29800     } catch (std::out_of_range& e) {
29801       {
29802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29803       };
29804     } catch (std::exception& e) {
29805       {
29806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29807       };
29808     } catch (Dali::DaliException e) {
29809       {
29810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29811       };
29812     } catch (...) {
29813       {
29814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29815       };
29816     }
29817   }
29818
29819   jresult = (void *)result;
29820   return jresult;
29821 }
29822
29823
29824 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Touch(void * jarg1) {
29825   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29826
29827   arg1 = (Dali::TouchData *)jarg1;
29828   {
29829     try {
29830       delete arg1;
29831     } catch (std::out_of_range& e) {
29832       {
29833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29834       };
29835     } catch (std::exception& e) {
29836       {
29837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29838       };
29839     } catch (Dali::DaliException e) {
29840       {
29841         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29842       };
29843     } catch (...) {
29844       {
29845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29846       };
29847     }
29848   }
29849
29850 }
29851
29852
29853 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_Assign(void * jarg1, void * jarg2) {
29854   void * jresult ;
29855   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29856   Dali::TouchData *arg2 = 0 ;
29857   Dali::TouchData *result = 0 ;
29858
29859   arg1 = (Dali::TouchData *)jarg1;
29860   arg2 = (Dali::TouchData *)jarg2;
29861   if (!arg2) {
29862     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
29863     return 0;
29864   }
29865   {
29866     try {
29867       result = (Dali::TouchData *) &(arg1)->operator =((Dali::TouchData const &)*arg2);
29868     } catch (std::out_of_range& e) {
29869       {
29870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29871       };
29872     } catch (std::exception& e) {
29873       {
29874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29875       };
29876     } catch (Dali::DaliException e) {
29877       {
29878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29879       };
29880     } catch (...) {
29881       {
29882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29883       };
29884     }
29885   }
29886
29887   jresult = (void *)result;
29888   return jresult;
29889 }
29890
29891
29892 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetTime(void * jarg1) {
29893   unsigned long jresult ;
29894   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29895   unsigned long result;
29896
29897   arg1 = (Dali::TouchData *)jarg1;
29898   {
29899     try {
29900       result = (unsigned long)((Dali::TouchData const *)arg1)->GetTime();
29901     } catch (std::out_of_range& e) {
29902       {
29903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29904       };
29905     } catch (std::exception& e) {
29906       {
29907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29908       };
29909     } catch (Dali::DaliException e) {
29910       {
29911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29912       };
29913     } catch (...) {
29914       {
29915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29916       };
29917     }
29918   }
29919
29920   jresult = (unsigned long)result;
29921   return jresult;
29922 }
29923
29924
29925 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetPointCount(void * jarg1) {
29926   unsigned long jresult ;
29927   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29928   std::size_t result;
29929
29930   arg1 = (Dali::TouchData *)jarg1;
29931   {
29932     try {
29933       result = ((Dali::TouchData const *)arg1)->GetPointCount();
29934     } catch (std::out_of_range& e) {
29935       {
29936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29937       };
29938     } catch (std::exception& e) {
29939       {
29940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29941       };
29942     } catch (Dali::DaliException e) {
29943       {
29944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29945       };
29946     } catch (...) {
29947       {
29948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29949       };
29950     }
29951   }
29952
29953   jresult = (unsigned long)result;
29954   return jresult;
29955 }
29956
29957
29958 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetDeviceId(void * jarg1, unsigned long jarg2) {
29959   int jresult ;
29960   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29961   std::size_t arg2 ;
29962   int32_t result;
29963
29964   arg1 = (Dali::TouchData *)jarg1;
29965   arg2 = (std::size_t)jarg2;
29966   {
29967     try {
29968       result = ((Dali::TouchData const *)arg1)->GetDeviceId(arg2);
29969     } catch (std::out_of_range& e) {
29970       {
29971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29972       };
29973     } catch (std::exception& e) {
29974       {
29975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29976       };
29977     } catch (Dali::DaliException e) {
29978       {
29979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29980       };
29981     } catch (...) {
29982       {
29983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29984       };
29985     }
29986   }
29987
29988   jresult = result;
29989   return jresult;
29990 }
29991
29992
29993 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetState(void * jarg1, unsigned long jarg2) {
29994   int jresult ;
29995   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29996   std::size_t arg2 ;
29997   Dali::PointState::Type result;
29998
29999   arg1 = (Dali::TouchData *)jarg1;
30000   arg2 = (std::size_t)jarg2;
30001   {
30002     try {
30003       result = (Dali::PointState::Type)((Dali::TouchData const *)arg1)->GetState(arg2);
30004     } catch (std::out_of_range& e) {
30005       {
30006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30007       };
30008     } catch (std::exception& e) {
30009       {
30010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30011       };
30012     } catch (Dali::DaliException e) {
30013       {
30014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30015       };
30016     } catch (...) {
30017       {
30018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30019       };
30020     }
30021   }
30022
30023   jresult = (int)result;
30024   return jresult;
30025 }
30026
30027
30028 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetHitActor(void * jarg1, unsigned long jarg2) {
30029   void * jresult ;
30030   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30031   std::size_t arg2 ;
30032   Dali::Actor result;
30033
30034   arg1 = (Dali::TouchData *)jarg1;
30035   arg2 = (std::size_t)jarg2;
30036   {
30037     try {
30038       result = ((Dali::TouchData const *)arg1)->GetHitActor(arg2);
30039     } catch (std::out_of_range& e) {
30040       {
30041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30042       };
30043     } catch (std::exception& e) {
30044       {
30045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30046       };
30047     } catch (Dali::DaliException e) {
30048       {
30049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30050       };
30051     } catch (...) {
30052       {
30053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30054       };
30055     }
30056   }
30057
30058   jresult = new Dali::Actor((const Dali::Actor &)result);
30059   return jresult;
30060 }
30061
30062
30063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetLocalPosition(void * jarg1, unsigned long jarg2) {
30064   void * jresult ;
30065   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30066   std::size_t arg2 ;
30067   Dali::Vector2 *result = 0 ;
30068
30069   arg1 = (Dali::TouchData *)jarg1;
30070   arg2 = (std::size_t)jarg2;
30071   {
30072     try {
30073       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetLocalPosition(arg2);
30074     } catch (std::out_of_range& e) {
30075       {
30076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30077       };
30078     } catch (std::exception& e) {
30079       {
30080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30081       };
30082     } catch (Dali::DaliException e) {
30083       {
30084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30085       };
30086     } catch (...) {
30087       {
30088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30089       };
30090     }
30091   }
30092
30093   jresult = (void *)result;
30094   return jresult;
30095 }
30096
30097
30098 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetScreenPosition(void * jarg1, unsigned long jarg2) {
30099   void * jresult ;
30100   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30101   std::size_t arg2 ;
30102   Dali::Vector2 *result = 0 ;
30103
30104   arg1 = (Dali::TouchData *)jarg1;
30105   arg2 = (std::size_t)jarg2;
30106   {
30107     try {
30108       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetScreenPosition(arg2);
30109     } catch (std::out_of_range& e) {
30110       {
30111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30112       };
30113     } catch (std::exception& e) {
30114       {
30115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30116       };
30117     } catch (Dali::DaliException e) {
30118       {
30119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30120       };
30121     } catch (...) {
30122       {
30123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30124       };
30125     }
30126   }
30127
30128   jresult = (void *)result;
30129   return jresult;
30130 }
30131
30132
30133 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetRadius(void * jarg1, unsigned long jarg2) {
30134   float jresult ;
30135   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30136   std::size_t arg2 ;
30137   float result;
30138
30139   arg1 = (Dali::TouchData *)jarg1;
30140   arg2 = (std::size_t)jarg2;
30141   {
30142     try {
30143       result = (float)((Dali::TouchData const *)arg1)->GetRadius(arg2);
30144     } catch (std::out_of_range& e) {
30145       {
30146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30147       };
30148     } catch (std::exception& e) {
30149       {
30150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30151       };
30152     } catch (Dali::DaliException e) {
30153       {
30154         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30155       };
30156     } catch (...) {
30157       {
30158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30159       };
30160     }
30161   }
30162
30163   jresult = result;
30164   return jresult;
30165 }
30166
30167
30168 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetEllipseRadius(void * jarg1, unsigned long jarg2) {
30169   void * jresult ;
30170   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30171   std::size_t arg2 ;
30172   Dali::Vector2 *result = 0 ;
30173
30174   arg1 = (Dali::TouchData *)jarg1;
30175   arg2 = (std::size_t)jarg2;
30176   {
30177     try {
30178       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetEllipseRadius(arg2);
30179     } catch (std::out_of_range& e) {
30180       {
30181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30182       };
30183     } catch (std::exception& e) {
30184       {
30185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30186       };
30187     } catch (Dali::DaliException e) {
30188       {
30189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30190       };
30191     } catch (...) {
30192       {
30193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30194       };
30195     }
30196   }
30197
30198   jresult = (void *)result;
30199   return jresult;
30200 }
30201
30202
30203 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetPressure(void * jarg1, unsigned long jarg2) {
30204   float jresult ;
30205   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30206   std::size_t arg2 ;
30207   float result;
30208
30209   arg1 = (Dali::TouchData *)jarg1;
30210   arg2 = (std::size_t)jarg2;
30211   {
30212     try {
30213       result = (float)((Dali::TouchData const *)arg1)->GetPressure(arg2);
30214     } catch (std::out_of_range& e) {
30215       {
30216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30217       };
30218     } catch (std::exception& e) {
30219       {
30220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30221       };
30222     } catch (Dali::DaliException e) {
30223       {
30224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30225       };
30226     } catch (...) {
30227       {
30228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30229       };
30230     }
30231   }
30232
30233   jresult = result;
30234   return jresult;
30235 }
30236
30237
30238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetAngle(void * jarg1, unsigned long jarg2) {
30239   void * jresult ;
30240   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30241   std::size_t arg2 ;
30242   Dali::Degree result;
30243
30244   arg1 = (Dali::TouchData *)jarg1;
30245   arg2 = (std::size_t)jarg2;
30246   {
30247     try {
30248       result = ((Dali::TouchData const *)arg1)->GetAngle(arg2);
30249     } catch (std::out_of_range& e) {
30250       {
30251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30252       };
30253     } catch (std::exception& e) {
30254       {
30255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30256       };
30257     } catch (Dali::DaliException e) {
30258       {
30259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30260       };
30261     } catch (...) {
30262       {
30263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30264       };
30265     }
30266   }
30267
30268   jresult = new Dali::Degree((const Dali::Degree &)result);
30269   return jresult;
30270 }
30271
30272
30273 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_0() {
30274   void * jresult ;
30275   Dali::GestureDetector *result = 0 ;
30276
30277   {
30278     try {
30279       result = (Dali::GestureDetector *)new Dali::GestureDetector();
30280     } catch (std::out_of_range& e) {
30281       {
30282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30283       };
30284     } catch (std::exception& e) {
30285       {
30286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30287       };
30288     } catch (Dali::DaliException e) {
30289       {
30290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30291       };
30292     } catch (...) {
30293       {
30294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30295       };
30296     }
30297   }
30298
30299   jresult = (void *)result;
30300   return jresult;
30301 }
30302
30303
30304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_DownCast(void * jarg1) {
30305   void * jresult ;
30306   Dali::BaseHandle arg1 ;
30307   Dali::BaseHandle *argp1 ;
30308   Dali::GestureDetector result;
30309
30310   argp1 = (Dali::BaseHandle *)jarg1;
30311   if (!argp1) {
30312     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
30313     return 0;
30314   }
30315   arg1 = *argp1;
30316   {
30317     try {
30318       result = Dali::GestureDetector::DownCast(arg1);
30319     } catch (std::out_of_range& e) {
30320       {
30321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30322       };
30323     } catch (std::exception& e) {
30324       {
30325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30326       };
30327     } catch (Dali::DaliException e) {
30328       {
30329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30330       };
30331     } catch (...) {
30332       {
30333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30334       };
30335     }
30336   }
30337
30338   jresult = new Dali::GestureDetector((const Dali::GestureDetector &)result);
30339   return jresult;
30340 }
30341
30342
30343 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GestureDetector(void * jarg1) {
30344   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30345
30346   arg1 = (Dali::GestureDetector *)jarg1;
30347   {
30348     try {
30349       delete arg1;
30350     } catch (std::out_of_range& e) {
30351       {
30352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30353       };
30354     } catch (std::exception& e) {
30355       {
30356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30357       };
30358     } catch (Dali::DaliException e) {
30359       {
30360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30361       };
30362     } catch (...) {
30363       {
30364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30365       };
30366     }
30367   }
30368
30369 }
30370
30371
30372 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_1(void * jarg1) {
30373   void * jresult ;
30374   Dali::GestureDetector *arg1 = 0 ;
30375   Dali::GestureDetector *result = 0 ;
30376
30377   arg1 = (Dali::GestureDetector *)jarg1;
30378   if (!arg1) {
30379     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
30380     return 0;
30381   }
30382   {
30383     try {
30384       result = (Dali::GestureDetector *)new Dali::GestureDetector((Dali::GestureDetector const &)*arg1);
30385     } catch (std::out_of_range& e) {
30386       {
30387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30388       };
30389     } catch (std::exception& e) {
30390       {
30391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30392       };
30393     } catch (Dali::DaliException e) {
30394       {
30395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30396       };
30397     } catch (...) {
30398       {
30399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30400       };
30401     }
30402   }
30403
30404   jresult = (void *)result;
30405   return jresult;
30406 }
30407
30408
30409 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_Assign(void * jarg1, void * jarg2) {
30410   void * jresult ;
30411   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30412   Dali::GestureDetector *arg2 = 0 ;
30413   Dali::GestureDetector *result = 0 ;
30414
30415   arg1 = (Dali::GestureDetector *)jarg1;
30416   arg2 = (Dali::GestureDetector *)jarg2;
30417   if (!arg2) {
30418     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
30419     return 0;
30420   }
30421   {
30422     try {
30423       result = (Dali::GestureDetector *) &(arg1)->operator =((Dali::GestureDetector const &)*arg2);
30424     } catch (std::out_of_range& e) {
30425       {
30426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30427       };
30428     } catch (std::exception& e) {
30429       {
30430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30431       };
30432     } catch (Dali::DaliException e) {
30433       {
30434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30435       };
30436     } catch (...) {
30437       {
30438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30439       };
30440     }
30441   }
30442
30443   jresult = (void *)result;
30444   return jresult;
30445 }
30446
30447
30448 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Attach(void * jarg1, void * jarg2) {
30449   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30450   Dali::Actor arg2 ;
30451   Dali::Actor *argp2 ;
30452
30453   arg1 = (Dali::GestureDetector *)jarg1;
30454   argp2 = (Dali::Actor *)jarg2;
30455   if (!argp2) {
30456     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
30457     return ;
30458   }
30459   arg2 = *argp2;
30460   {
30461     try {
30462       (arg1)->Attach(arg2);
30463     } catch (std::out_of_range& e) {
30464       {
30465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30466       };
30467     } catch (std::exception& e) {
30468       {
30469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30470       };
30471     } catch (Dali::DaliException e) {
30472       {
30473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30474       };
30475     } catch (...) {
30476       {
30477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30478       };
30479     }
30480   }
30481
30482 }
30483
30484
30485 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Detach(void * jarg1, void * jarg2) {
30486   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30487   Dali::Actor arg2 ;
30488   Dali::Actor *argp2 ;
30489
30490   arg1 = (Dali::GestureDetector *)jarg1;
30491   argp2 = (Dali::Actor *)jarg2;
30492   if (!argp2) {
30493     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
30494     return ;
30495   }
30496   arg2 = *argp2;
30497   {
30498     try {
30499       (arg1)->Detach(arg2);
30500     } catch (std::out_of_range& e) {
30501       {
30502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30503       };
30504     } catch (std::exception& e) {
30505       {
30506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30507       };
30508     } catch (Dali::DaliException e) {
30509       {
30510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30511       };
30512     } catch (...) {
30513       {
30514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30515       };
30516     }
30517   }
30518
30519 }
30520
30521
30522 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_DetachAll(void * jarg1) {
30523   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30524
30525   arg1 = (Dali::GestureDetector *)jarg1;
30526   {
30527     try {
30528       (arg1)->DetachAll();
30529     } catch (std::out_of_range& e) {
30530       {
30531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30532       };
30533     } catch (std::exception& e) {
30534       {
30535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30536       };
30537     } catch (Dali::DaliException e) {
30538       {
30539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30540       };
30541     } catch (...) {
30542       {
30543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30544       };
30545     }
30546   }
30547
30548 }
30549
30550
30551 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActorCount(void * jarg1) {
30552   unsigned long jresult ;
30553   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30554   size_t result;
30555
30556   arg1 = (Dali::GestureDetector *)jarg1;
30557   {
30558     try {
30559       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActorCount();
30560     } catch (std::out_of_range& e) {
30561       {
30562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30563       };
30564     } catch (std::exception& e) {
30565       {
30566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30567       };
30568     } catch (Dali::DaliException e) {
30569       {
30570         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30571       };
30572     } catch (...) {
30573       {
30574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30575       };
30576     }
30577   }
30578
30579   jresult = (unsigned long)result;
30580   return jresult;
30581 }
30582
30583
30584 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActor(void * jarg1, unsigned long jarg2) {
30585   void * jresult ;
30586   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30587   size_t arg2 ;
30588   Dali::Actor result;
30589
30590   arg1 = (Dali::GestureDetector *)jarg1;
30591   arg2 = (size_t)jarg2;
30592   {
30593     try {
30594       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActor(arg2);
30595     } catch (std::out_of_range& e) {
30596       {
30597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30598       };
30599     } catch (std::exception& e) {
30600       {
30601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30602       };
30603     } catch (Dali::DaliException e) {
30604       {
30605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30606       };
30607     } catch (...) {
30608       {
30609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30610       };
30611     }
30612   }
30613
30614   jresult = new Dali::Actor((const Dali::Actor &)result);
30615   return jresult;
30616 }
30617
30618
30619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Gesture(void * jarg1) {
30620   void * jresult ;
30621   Dali::Gesture *arg1 = 0 ;
30622   Dali::Gesture *result = 0 ;
30623
30624   arg1 = (Dali::Gesture *)jarg1;
30625   if (!arg1) {
30626     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
30627     return 0;
30628   }
30629   {
30630     try {
30631       result = (Dali::Gesture *)new Dali::Gesture((Dali::Gesture const &)*arg1);
30632     } catch (std::out_of_range& e) {
30633       {
30634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30635       };
30636     } catch (std::exception& e) {
30637       {
30638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30639       };
30640     } catch (Dali::DaliException e) {
30641       {
30642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30643       };
30644     } catch (...) {
30645       {
30646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30647       };
30648     }
30649   }
30650
30651   jresult = (void *)result;
30652   return jresult;
30653 }
30654
30655
30656 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Gesture_Assign(void * jarg1, void * jarg2) {
30657   void * jresult ;
30658   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30659   Dali::Gesture *arg2 = 0 ;
30660   Dali::Gesture *result = 0 ;
30661
30662   arg1 = (Dali::Gesture *)jarg1;
30663   arg2 = (Dali::Gesture *)jarg2;
30664   if (!arg2) {
30665     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
30666     return 0;
30667   }
30668   {
30669     try {
30670       result = (Dali::Gesture *) &(arg1)->operator =((Dali::Gesture const &)*arg2);
30671     } catch (std::out_of_range& e) {
30672       {
30673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30674       };
30675     } catch (std::exception& e) {
30676       {
30677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30678       };
30679     } catch (Dali::DaliException e) {
30680       {
30681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30682       };
30683     } catch (...) {
30684       {
30685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30686       };
30687     }
30688   }
30689
30690   jresult = (void *)result;
30691   return jresult;
30692 }
30693
30694
30695 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Gesture(void * jarg1) {
30696   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30697
30698   arg1 = (Dali::Gesture *)jarg1;
30699   {
30700     try {
30701       delete arg1;
30702     } catch (std::out_of_range& e) {
30703       {
30704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30705       };
30706     } catch (std::exception& e) {
30707       {
30708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30709       };
30710     } catch (Dali::DaliException e) {
30711       {
30712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30713       };
30714     } catch (...) {
30715       {
30716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30717       };
30718     }
30719   }
30720
30721 }
30722
30723
30724 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_type_set(void * jarg1, int jarg2) {
30725   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30726   Dali::Gesture::Type arg2 ;
30727
30728   arg1 = (Dali::Gesture *)jarg1;
30729   arg2 = (Dali::Gesture::Type)jarg2;
30730   if (arg1) (arg1)->type = arg2;
30731 }
30732
30733
30734 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_type_get(void * jarg1) {
30735   int jresult ;
30736   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30737   Dali::Gesture::Type result;
30738
30739   arg1 = (Dali::Gesture *)jarg1;
30740   result = (Dali::Gesture::Type) ((arg1)->type);
30741   jresult = (int)result;
30742   return jresult;
30743 }
30744
30745
30746 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_state_set(void * jarg1, int jarg2) {
30747   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30748   Dali::Gesture::State arg2 ;
30749
30750   arg1 = (Dali::Gesture *)jarg1;
30751   arg2 = (Dali::Gesture::State)jarg2;
30752   if (arg1) (arg1)->state = arg2;
30753 }
30754
30755
30756 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_state_get(void * jarg1) {
30757   int jresult ;
30758   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30759   Dali::Gesture::State result;
30760
30761   arg1 = (Dali::Gesture *)jarg1;
30762   result = (Dali::Gesture::State) ((arg1)->state);
30763   jresult = (int)result;
30764   return jresult;
30765 }
30766
30767
30768 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_time_set(void * jarg1, unsigned int jarg2) {
30769   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30770   unsigned int arg2 ;
30771
30772   arg1 = (Dali::Gesture *)jarg1;
30773   arg2 = (unsigned int)jarg2;
30774   if (arg1) (arg1)->time = arg2;
30775 }
30776
30777
30778 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Gesture_time_get(void * jarg1) {
30779   unsigned int jresult ;
30780   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30781   unsigned int result;
30782
30783   arg1 = (Dali::Gesture *)jarg1;
30784   result = (unsigned int) ((arg1)->time);
30785   jresult = result;
30786   return jresult;
30787 }
30788
30789
30790 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_0() {
30791   void * jresult ;
30792   Dali::HoverEvent *result = 0 ;
30793
30794   {
30795     try {
30796       result = (Dali::HoverEvent *)new Dali::HoverEvent();
30797     } catch (std::out_of_range& e) {
30798       {
30799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30800       };
30801     } catch (std::exception& e) {
30802       {
30803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30804       };
30805     } catch (Dali::DaliException e) {
30806       {
30807         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30808       };
30809     } catch (...) {
30810       {
30811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30812       };
30813     }
30814   }
30815
30816   jresult = (void *)result;
30817   return jresult;
30818 }
30819
30820
30821 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_1(unsigned long jarg1) {
30822   void * jresult ;
30823   unsigned long arg1 ;
30824   Dali::HoverEvent *result = 0 ;
30825
30826   arg1 = (unsigned long)jarg1;
30827   {
30828     try {
30829       result = (Dali::HoverEvent *)new Dali::HoverEvent(arg1);
30830     } catch (std::out_of_range& e) {
30831       {
30832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30833       };
30834     } catch (std::exception& e) {
30835       {
30836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30837       };
30838     } catch (Dali::DaliException e) {
30839       {
30840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30841       };
30842     } catch (...) {
30843       {
30844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30845       };
30846     }
30847   }
30848
30849   jresult = (void *)result;
30850   return jresult;
30851 }
30852
30853
30854 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Hover(void * jarg1) {
30855   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30856
30857   arg1 = (Dali::HoverEvent *)jarg1;
30858   {
30859     try {
30860       delete arg1;
30861     } catch (std::out_of_range& e) {
30862       {
30863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30864       };
30865     } catch (std::exception& e) {
30866       {
30867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30868       };
30869     } catch (Dali::DaliException e) {
30870       {
30871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30872       };
30873     } catch (...) {
30874       {
30875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30876       };
30877     }
30878   }
30879
30880 }
30881
30882
30883 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_points_set(void * jarg1, void * jarg2) {
30884   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30885   Dali::TouchPointContainer *arg2 = (Dali::TouchPointContainer *) 0 ;
30886
30887   arg1 = (Dali::HoverEvent *)jarg1;
30888   arg2 = (Dali::TouchPointContainer *)jarg2;
30889   if (arg1) (arg1)->points = *arg2;
30890 }
30891
30892
30893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_points_get(void * jarg1) {
30894   void * jresult ;
30895   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30896   Dali::TouchPointContainer *result = 0 ;
30897
30898   arg1 = (Dali::HoverEvent *)jarg1;
30899   result = (Dali::TouchPointContainer *)& ((arg1)->points);
30900   jresult = (void *)result;
30901   return jresult;
30902 }
30903
30904
30905 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_time_set(void * jarg1, unsigned long jarg2) {
30906   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30907   unsigned long arg2 ;
30908
30909   arg1 = (Dali::HoverEvent *)jarg1;
30910   arg2 = (unsigned long)jarg2;
30911   if (arg1) (arg1)->time = arg2;
30912 }
30913
30914
30915 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Hover_time_get(void * jarg1) {
30916   unsigned long jresult ;
30917   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30918   unsigned long result;
30919
30920   arg1 = (Dali::HoverEvent *)jarg1;
30921   result = (unsigned long) ((arg1)->time);
30922   jresult = (unsigned long)result;
30923   return jresult;
30924 }
30925
30926
30927 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Hover_GetPointCount(void * jarg1) {
30928   unsigned int jresult ;
30929   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30930   unsigned int result;
30931
30932   arg1 = (Dali::HoverEvent *)jarg1;
30933   {
30934     try {
30935       result = (unsigned int)((Dali::HoverEvent const *)arg1)->GetPointCount();
30936     } catch (std::out_of_range& e) {
30937       {
30938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30939       };
30940     } catch (std::exception& e) {
30941       {
30942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30943       };
30944     } catch (Dali::DaliException e) {
30945       {
30946         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30947       };
30948     } catch (...) {
30949       {
30950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30951       };
30952     }
30953   }
30954
30955   jresult = result;
30956   return jresult;
30957 }
30958
30959
30960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetPoint(void * jarg1, unsigned int jarg2) {
30961   void * jresult ;
30962   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30963   unsigned int arg2 ;
30964   Dali::TouchPoint *result = 0 ;
30965
30966   arg1 = (Dali::HoverEvent *)jarg1;
30967   arg2 = (unsigned int)jarg2;
30968   {
30969     try {
30970       result = (Dali::TouchPoint *) &((Dali::HoverEvent const *)arg1)->GetPoint(arg2);
30971     } catch (std::out_of_range& e) {
30972       {
30973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30974       };
30975     } catch (std::exception& e) {
30976       {
30977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30978       };
30979     } catch (Dali::DaliException e) {
30980       {
30981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30982       };
30983     } catch (...) {
30984       {
30985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30986       };
30987     }
30988   }
30989
30990   jresult = (void *)result;
30991   return jresult;
30992 }
30993
30994
30995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_0() {
30996   void * jresult ;
30997   Dali::KeyEvent *result = 0 ;
30998
30999   {
31000     try {
31001       result = (Dali::KeyEvent *)new Dali::KeyEvent();
31002     } catch (std::out_of_range& e) {
31003       {
31004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31005       };
31006     } catch (std::exception& e) {
31007       {
31008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31009       };
31010     } catch (Dali::DaliException e) {
31011       {
31012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31013       };
31014     } catch (...) {
31015       {
31016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31017       };
31018     }
31019   }
31020
31021   jresult = (void *)result;
31022   return jresult;
31023 }
31024
31025
31026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_1(char * jarg1, char * jarg2, int jarg3, int jarg4, unsigned long jarg5, int jarg6) {
31027   void * jresult ;
31028   std::string *arg1 = 0 ;
31029   std::string *arg2 = 0 ;
31030   int arg3 ;
31031   int arg4 ;
31032   unsigned long arg5 ;
31033   Dali::KeyEvent::State *arg6 = 0 ;
31034   Dali::KeyEvent::State temp6 ;
31035   Dali::KeyEvent *result = 0 ;
31036
31037   if (!jarg1) {
31038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31039     return 0;
31040   }
31041   std::string arg1_str(jarg1);
31042   arg1 = &arg1_str;
31043   if (!jarg2) {
31044     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31045     return 0;
31046   }
31047   std::string arg2_str(jarg2);
31048   arg2 = &arg2_str;
31049   arg3 = (int)jarg3;
31050   arg4 = (int)jarg4;
31051   arg5 = (unsigned long)jarg5;
31052   temp6 = (Dali::KeyEvent::State)jarg6;
31053   arg6 = &temp6;
31054   {
31055     try {
31056       result = (Dali::KeyEvent *)new Dali::KeyEvent((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,(Dali::KeyEvent::State const &)*arg6);
31057     } catch (std::out_of_range& e) {
31058       {
31059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31060       };
31061     } catch (std::exception& e) {
31062       {
31063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31064       };
31065     } catch (Dali::DaliException e) {
31066       {
31067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31068       };
31069     } catch (...) {
31070       {
31071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31072       };
31073     }
31074   }
31075
31076   jresult = (void *)result;
31077
31078   //argout typemap for const std::string&
31079
31080
31081   //argout typemap for const std::string&
31082
31083   return jresult;
31084 }
31085
31086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_2(void * jarg1) {
31087   void * jresult ;
31088   Dali::KeyEvent *arg1 = 0 ;
31089   Dali::KeyEvent *result = 0 ;
31090
31091   arg1 = (Dali::KeyEvent *)jarg1;
31092   if (!arg1) {
31093     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
31094     return 0;
31095   }
31096   {
31097     try {
31098       result = (Dali::KeyEvent *)new Dali::KeyEvent((Dali::KeyEvent const &)*arg1);
31099     } catch (std::out_of_range& e) {
31100       {
31101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31102       };
31103     } catch (std::exception& e) {
31104       {
31105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31106       };
31107     } catch (Dali::DaliException e) {
31108       {
31109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31110       };
31111     } catch (...) {
31112       {
31113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31114       };
31115     }
31116   }
31117
31118   jresult = (void *)result;
31119   return jresult;
31120 }
31121
31122
31123 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Key_Assign(void * jarg1, void * jarg2) {
31124   void * jresult ;
31125   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31126   Dali::KeyEvent *arg2 = 0 ;
31127   Dali::KeyEvent *result = 0 ;
31128
31129   arg1 = (Dali::KeyEvent *)jarg1;
31130   arg2 = (Dali::KeyEvent *)jarg2;
31131   if (!arg2) {
31132     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
31133     return 0;
31134   }
31135   {
31136     try {
31137       result = (Dali::KeyEvent *) &(arg1)->operator =((Dali::KeyEvent const &)*arg2);
31138     } catch (std::out_of_range& e) {
31139       {
31140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31141       };
31142     } catch (std::exception& e) {
31143       {
31144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31145       };
31146     } catch (Dali::DaliException e) {
31147       {
31148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31149       };
31150     } catch (...) {
31151       {
31152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31153       };
31154     }
31155   }
31156
31157   jresult = (void *)result;
31158   return jresult;
31159 }
31160
31161
31162 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Key(void * jarg1) {
31163   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31164
31165   arg1 = (Dali::KeyEvent *)jarg1;
31166   {
31167     try {
31168       delete arg1;
31169     } catch (std::out_of_range& e) {
31170       {
31171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31172       };
31173     } catch (std::exception& e) {
31174       {
31175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31176       };
31177     } catch (Dali::DaliException e) {
31178       {
31179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31180       };
31181     } catch (...) {
31182       {
31183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31184       };
31185     }
31186   }
31187
31188 }
31189
31190
31191 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsShiftModifier(void * jarg1) {
31192   unsigned int jresult ;
31193   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31194   bool result;
31195
31196   arg1 = (Dali::KeyEvent *)jarg1;
31197   {
31198     try {
31199       result = (bool)((Dali::KeyEvent const *)arg1)->IsShiftModifier();
31200     } catch (std::out_of_range& e) {
31201       {
31202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31203       };
31204     } catch (std::exception& e) {
31205       {
31206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31207       };
31208     } catch (Dali::DaliException e) {
31209       {
31210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31211       };
31212     } catch (...) {
31213       {
31214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31215       };
31216     }
31217   }
31218
31219   jresult = result;
31220   return jresult;
31221 }
31222
31223
31224 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsCtrlModifier(void * jarg1) {
31225   unsigned int jresult ;
31226   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31227   bool result;
31228
31229   arg1 = (Dali::KeyEvent *)jarg1;
31230   {
31231     try {
31232       result = (bool)((Dali::KeyEvent const *)arg1)->IsCtrlModifier();
31233     } catch (std::out_of_range& e) {
31234       {
31235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31236       };
31237     } catch (std::exception& e) {
31238       {
31239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31240       };
31241     } catch (Dali::DaliException e) {
31242       {
31243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31244       };
31245     } catch (...) {
31246       {
31247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31248       };
31249     }
31250   }
31251
31252   jresult = result;
31253   return jresult;
31254 }
31255
31256
31257 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsAltModifier(void * jarg1) {
31258   unsigned int jresult ;
31259   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31260   bool result;
31261
31262   arg1 = (Dali::KeyEvent *)jarg1;
31263   {
31264     try {
31265       result = (bool)((Dali::KeyEvent const *)arg1)->IsAltModifier();
31266     } catch (std::out_of_range& e) {
31267       {
31268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31269       };
31270     } catch (std::exception& e) {
31271       {
31272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31273       };
31274     } catch (Dali::DaliException e) {
31275       {
31276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31277       };
31278     } catch (...) {
31279       {
31280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31281       };
31282     }
31283   }
31284
31285   jresult = result;
31286   return jresult;
31287 }
31288
31289
31290 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressedName_set(void * jarg1, char * jarg2) {
31291   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31292   std::string *arg2 = 0 ;
31293
31294   arg1 = (Dali::KeyEvent *)jarg1;
31295   if (!jarg2) {
31296     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31297     return ;
31298   }
31299   std::string arg2_str(jarg2);
31300   arg2 = &arg2_str;
31301   if (arg1) (arg1)->keyPressedName = *arg2;
31302
31303   //argout typemap for const std::string&
31304
31305 }
31306
31307
31308 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressedName_get(void * jarg1) {
31309   char * jresult ;
31310
31311   if( jarg1 == NULL )
31312   {
31313     jresult = SWIG_csharp_string_callback( "" );
31314   }
31315   else
31316   {
31317     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31318     std::string *result = 0;
31319
31320     arg1 = ( Dali::KeyEvent * )jarg1;
31321     result = ( std::string * ) & ( ( arg1 )->keyPressedName );
31322     jresult = SWIG_csharp_string_callback( result->c_str() );
31323   }
31324
31325   return jresult;
31326 }
31327
31328
31329 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressed_set(void * jarg1, char * jarg2) {
31330   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31331   std::string *arg2 = 0 ;
31332
31333   arg1 = (Dali::KeyEvent *)jarg1;
31334   if (!jarg2) {
31335     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31336     return ;
31337   }
31338   std::string arg2_str(jarg2);
31339   arg2 = &arg2_str;
31340   if (arg1) (arg1)->keyPressed = *arg2;
31341
31342   //argout typemap for const std::string&
31343
31344 }
31345
31346
31347 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressed_get(void * jarg1) {
31348   char * jresult ;
31349   if( NULL == jarg1 )
31350   {
31351     jresult = SWIG_csharp_string_callback( "" );
31352   }
31353   else
31354   {
31355     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31356     std::string *result = 0;
31357
31358     arg1 = ( Dali::KeyEvent * )jarg1;
31359     result = ( std::string * ) & ( ( arg1 )->keyPressed );
31360     jresult = SWIG_csharp_string_callback( result->c_str() );
31361   }
31362   return jresult;
31363 }
31364
31365
31366 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyCode_set(void * jarg1, int jarg2) {
31367   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31368   int arg2 ;
31369
31370   arg1 = (Dali::KeyEvent *)jarg1;
31371   arg2 = (int)jarg2;
31372   if (arg1) (arg1)->keyCode = arg2;
31373 }
31374
31375
31376 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyCode_get(void * jarg1) {
31377   int jresult ;
31378   if( NULL == jarg1 )
31379   {
31380     jresult = -1;
31381   }
31382   else
31383   {
31384     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31385     int result;
31386
31387     arg1 = ( Dali::KeyEvent * )jarg1;
31388     result = (int)( ( arg1 )->keyCode );
31389     jresult = result;
31390   }
31391   return jresult;
31392 }
31393
31394
31395 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyModifier_set(void * jarg1, int jarg2) {
31396   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31397   int arg2 ;
31398
31399   arg1 = (Dali::KeyEvent *)jarg1;
31400   arg2 = (int)jarg2;
31401   if (arg1) (arg1)->keyModifier = arg2;
31402 }
31403
31404
31405 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyModifier_get(void * jarg1) {
31406   int jresult ;
31407   if( jarg1 == NULL )
31408   {
31409     jresult = -1;
31410   }
31411   else
31412   {
31413     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31414     int result;
31415
31416     arg1 = ( Dali::KeyEvent * )jarg1;
31417     result = (int)( ( arg1 )->keyModifier );
31418     jresult = result;
31419   }
31420   return jresult;
31421 }
31422
31423
31424 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_time_set(void * jarg1, unsigned long jarg2) {
31425   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31426   unsigned long arg2 ;
31427
31428   arg1 = (Dali::KeyEvent *)jarg1;
31429   arg2 = (unsigned long)jarg2;
31430   if (arg1) (arg1)->time = arg2;
31431 }
31432
31433
31434 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Key_time_get(void * jarg1) {
31435   unsigned long jresult ;
31436   if( jarg1 == NULL )
31437   {
31438     jresult = 0;
31439   }
31440   else
31441   {
31442     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31443     unsigned long result;
31444
31445     arg1 = ( Dali::KeyEvent * )jarg1;
31446     result = (unsigned long)( ( arg1 )->time );
31447     jresult = (unsigned long)result;
31448   }
31449   return jresult;
31450 }
31451
31452
31453 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_state_set(void * jarg1, int jarg2) {
31454   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31455   Dali::KeyEvent::State arg2 ;
31456
31457   arg1 = (Dali::KeyEvent *)jarg1;
31458   arg2 = (Dali::KeyEvent::State)jarg2;
31459   if (arg1) (arg1)->state = arg2;
31460 }
31461
31462
31463 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_state_get(void * jarg1) {
31464   int jresult ;
31465   if( jarg1 == NULL )
31466   {
31467     jresult = -1;
31468   }
31469   else
31470   {
31471     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31472     Dali::KeyEvent::State result;
31473
31474     arg1 = ( Dali::KeyEvent * )jarg1;
31475     result = ( Dali::KeyEvent::State ) ( ( arg1 )->state );
31476     jresult = (int)result;
31477   }
31478   return jresult;
31479 }
31480
31481
31482 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_0() {
31483   void * jresult ;
31484   Dali::LongPressGestureDetector *result = 0 ;
31485
31486   {
31487     try {
31488       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector();
31489     } catch (std::out_of_range& e) {
31490       {
31491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31492       };
31493     } catch (std::exception& e) {
31494       {
31495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31496       };
31497     } catch (Dali::DaliException e) {
31498       {
31499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31500       };
31501     } catch (...) {
31502       {
31503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31504       };
31505     }
31506   }
31507
31508   jresult = (void *)result;
31509   return jresult;
31510 }
31511
31512
31513 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_0() {
31514   void * jresult ;
31515   Dali::LongPressGestureDetector result;
31516
31517   {
31518     try {
31519       result = Dali::LongPressGestureDetector::New();
31520     } catch (std::out_of_range& e) {
31521       {
31522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31523       };
31524     } catch (std::exception& e) {
31525       {
31526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31527       };
31528     } catch (Dali::DaliException e) {
31529       {
31530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31531       };
31532     } catch (...) {
31533       {
31534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31535       };
31536     }
31537   }
31538
31539   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31540   return jresult;
31541 }
31542
31543
31544 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_1(unsigned int jarg1) {
31545   void * jresult ;
31546   unsigned int arg1 ;
31547   Dali::LongPressGestureDetector result;
31548
31549   arg1 = (unsigned int)jarg1;
31550   {
31551     try {
31552       result = Dali::LongPressGestureDetector::New(arg1);
31553     } catch (std::out_of_range& e) {
31554       {
31555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31556       };
31557     } catch (std::exception& e) {
31558       {
31559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31560       };
31561     } catch (Dali::DaliException e) {
31562       {
31563         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31564       };
31565     } catch (...) {
31566       {
31567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31568       };
31569     }
31570   }
31571
31572   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31573   return jresult;
31574 }
31575
31576
31577 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
31578   void * jresult ;
31579   unsigned int arg1 ;
31580   unsigned int arg2 ;
31581   Dali::LongPressGestureDetector result;
31582
31583   arg1 = (unsigned int)jarg1;
31584   arg2 = (unsigned int)jarg2;
31585   {
31586     try {
31587       result = Dali::LongPressGestureDetector::New(arg1,arg2);
31588     } catch (std::out_of_range& e) {
31589       {
31590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31591       };
31592     } catch (std::exception& e) {
31593       {
31594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31595       };
31596     } catch (Dali::DaliException e) {
31597       {
31598         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31599       };
31600     } catch (...) {
31601       {
31602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31603       };
31604     }
31605   }
31606
31607   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31608   return jresult;
31609 }
31610
31611
31612 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DownCast(void * jarg1) {
31613   void * jresult ;
31614   Dali::BaseHandle arg1 ;
31615   Dali::BaseHandle *argp1 ;
31616   Dali::LongPressGestureDetector result;
31617
31618   argp1 = (Dali::BaseHandle *)jarg1;
31619   if (!argp1) {
31620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
31621     return 0;
31622   }
31623   arg1 = *argp1;
31624   {
31625     try {
31626       result = Dali::LongPressGestureDetector::DownCast(arg1);
31627     } catch (std::out_of_range& e) {
31628       {
31629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31630       };
31631     } catch (std::exception& e) {
31632       {
31633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31634       };
31635     } catch (Dali::DaliException e) {
31636       {
31637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31638       };
31639     } catch (...) {
31640       {
31641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31642       };
31643     }
31644   }
31645
31646   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31647   return jresult;
31648 }
31649
31650
31651 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetector(void * jarg1) {
31652   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31653
31654   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31655   {
31656     try {
31657       delete arg1;
31658     } catch (std::out_of_range& e) {
31659       {
31660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31661       };
31662     } catch (std::exception& e) {
31663       {
31664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31665       };
31666     } catch (Dali::DaliException e) {
31667       {
31668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31669       };
31670     } catch (...) {
31671       {
31672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31673       };
31674     }
31675   }
31676
31677 }
31678
31679
31680 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_1(void * jarg1) {
31681   void * jresult ;
31682   Dali::LongPressGestureDetector *arg1 = 0 ;
31683   Dali::LongPressGestureDetector *result = 0 ;
31684
31685   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31686   if (!arg1) {
31687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
31688     return 0;
31689   }
31690   {
31691     try {
31692       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector((Dali::LongPressGestureDetector const &)*arg1);
31693     } catch (std::out_of_range& e) {
31694       {
31695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31696       };
31697     } catch (std::exception& e) {
31698       {
31699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31700       };
31701     } catch (Dali::DaliException e) {
31702       {
31703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31704       };
31705     } catch (...) {
31706       {
31707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31708       };
31709     }
31710   }
31711
31712   jresult = (void *)result;
31713   return jresult;
31714 }
31715
31716
31717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_Assign(void * jarg1, void * jarg2) {
31718   void * jresult ;
31719   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31720   Dali::LongPressGestureDetector *arg2 = 0 ;
31721   Dali::LongPressGestureDetector *result = 0 ;
31722
31723   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31724   arg2 = (Dali::LongPressGestureDetector *)jarg2;
31725   if (!arg2) {
31726     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
31727     return 0;
31728   }
31729   {
31730     try {
31731       result = (Dali::LongPressGestureDetector *) &(arg1)->operator =((Dali::LongPressGestureDetector const &)*arg2);
31732     } catch (std::out_of_range& e) {
31733       {
31734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31735       };
31736     } catch (std::exception& e) {
31737       {
31738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31739       };
31740     } catch (Dali::DaliException e) {
31741       {
31742         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31743       };
31744     } catch (...) {
31745       {
31746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31747       };
31748     }
31749   }
31750
31751   jresult = (void *)result;
31752   return jresult;
31753 }
31754
31755
31756 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_0(void * jarg1, unsigned int jarg2) {
31757   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31758   unsigned int arg2 ;
31759
31760   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31761   arg2 = (unsigned int)jarg2;
31762   {
31763     try {
31764       (arg1)->SetTouchesRequired(arg2);
31765     } catch (std::out_of_range& e) {
31766       {
31767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31768       };
31769     } catch (std::exception& e) {
31770       {
31771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31772       };
31773     } catch (Dali::DaliException e) {
31774       {
31775         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31776       };
31777     } catch (...) {
31778       {
31779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31780       };
31781     }
31782   }
31783
31784 }
31785
31786
31787 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
31788   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31789   unsigned int arg2 ;
31790   unsigned int arg3 ;
31791
31792   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31793   arg2 = (unsigned int)jarg2;
31794   arg3 = (unsigned int)jarg3;
31795   {
31796     try {
31797       (arg1)->SetTouchesRequired(arg2,arg3);
31798     } catch (std::out_of_range& e) {
31799       {
31800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31801       };
31802     } catch (std::exception& e) {
31803       {
31804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31805       };
31806     } catch (Dali::DaliException e) {
31807       {
31808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31809       };
31810     } catch (...) {
31811       {
31812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31813       };
31814     }
31815   }
31816
31817 }
31818
31819
31820 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
31821   unsigned int jresult ;
31822   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31823   unsigned int result;
31824
31825   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31826   {
31827     try {
31828       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMinimumTouchesRequired();
31829     } catch (std::out_of_range& e) {
31830       {
31831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31832       };
31833     } catch (std::exception& e) {
31834       {
31835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31836       };
31837     } catch (Dali::DaliException e) {
31838       {
31839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31840       };
31841     } catch (...) {
31842       {
31843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31844       };
31845     }
31846   }
31847
31848   jresult = result;
31849   return jresult;
31850 }
31851
31852
31853 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
31854   unsigned int jresult ;
31855   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31856   unsigned int result;
31857
31858   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31859   {
31860     try {
31861       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMaximumTouchesRequired();
31862     } catch (std::out_of_range& e) {
31863       {
31864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31865       };
31866     } catch (std::exception& e) {
31867       {
31868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31869       };
31870     } catch (Dali::DaliException e) {
31871       {
31872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31873       };
31874     } catch (...) {
31875       {
31876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31877       };
31878     }
31879   }
31880
31881   jresult = result;
31882   return jresult;
31883 }
31884
31885
31886 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DetectedSignal(void * jarg1) {
31887   void * jresult ;
31888   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31889   Dali::LongPressGestureDetector::DetectedSignalType *result = 0 ;
31890
31891   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31892   {
31893     try {
31894       result = (Dali::LongPressGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
31895     } catch (std::out_of_range& e) {
31896       {
31897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31898       };
31899     } catch (std::exception& e) {
31900       {
31901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31902       };
31903     } catch (Dali::DaliException e) {
31904       {
31905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31906       };
31907     } catch (...) {
31908       {
31909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31910       };
31911     }
31912   }
31913
31914   jresult = (void *)result;
31915   return jresult;
31916 }
31917
31918
31919 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_0(int jarg1) {
31920   void * jresult ;
31921   Dali::Gesture::State arg1 ;
31922   Dali::LongPressGesture *result = 0 ;
31923
31924   arg1 = (Dali::Gesture::State)jarg1;
31925   {
31926     try {
31927       result = (Dali::LongPressGesture *)new Dali::LongPressGesture(arg1);
31928     } catch (std::out_of_range& e) {
31929       {
31930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31931       };
31932     } catch (std::exception& e) {
31933       {
31934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31935       };
31936     } catch (Dali::DaliException e) {
31937       {
31938         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31939       };
31940     } catch (...) {
31941       {
31942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31943       };
31944     }
31945   }
31946
31947   jresult = (void *)result;
31948   return jresult;
31949 }
31950
31951
31952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_1(void * jarg1) {
31953   void * jresult ;
31954   Dali::LongPressGesture *arg1 = 0 ;
31955   Dali::LongPressGesture *result = 0 ;
31956
31957   arg1 = (Dali::LongPressGesture *)jarg1;
31958   if (!arg1) {
31959     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
31960     return 0;
31961   }
31962   {
31963     try {
31964       result = (Dali::LongPressGesture *)new Dali::LongPressGesture((Dali::LongPressGesture const &)*arg1);
31965     } catch (std::out_of_range& e) {
31966       {
31967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31968       };
31969     } catch (std::exception& e) {
31970       {
31971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31972       };
31973     } catch (Dali::DaliException e) {
31974       {
31975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31976       };
31977     } catch (...) {
31978       {
31979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31980       };
31981     }
31982   }
31983
31984   jresult = (void *)result;
31985   return jresult;
31986 }
31987
31988
31989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_Assign(void * jarg1, void * jarg2) {
31990   void * jresult ;
31991   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31992   Dali::LongPressGesture *arg2 = 0 ;
31993   Dali::LongPressGesture *result = 0 ;
31994
31995   arg1 = (Dali::LongPressGesture *)jarg1;
31996   arg2 = (Dali::LongPressGesture *)jarg2;
31997   if (!arg2) {
31998     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
31999     return 0;
32000   }
32001   {
32002     try {
32003       result = (Dali::LongPressGesture *) &(arg1)->operator =((Dali::LongPressGesture const &)*arg2);
32004     } catch (std::out_of_range& e) {
32005       {
32006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32007       };
32008     } catch (std::exception& e) {
32009       {
32010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32011       };
32012     } catch (Dali::DaliException e) {
32013       {
32014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32015       };
32016     } catch (...) {
32017       {
32018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32019       };
32020     }
32021   }
32022
32023   jresult = (void *)result;
32024   return jresult;
32025 }
32026
32027
32028 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGesture(void * jarg1) {
32029   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32030
32031   arg1 = (Dali::LongPressGesture *)jarg1;
32032   {
32033     try {
32034       delete arg1;
32035     } catch (std::out_of_range& e) {
32036       {
32037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32038       };
32039     } catch (std::exception& e) {
32040       {
32041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32042       };
32043     } catch (Dali::DaliException e) {
32044       {
32045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32046       };
32047     } catch (...) {
32048       {
32049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32050       };
32051     }
32052   }
32053
32054 }
32055
32056
32057 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
32058   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32059   unsigned int arg2 ;
32060
32061   arg1 = (Dali::LongPressGesture *)jarg1;
32062   arg2 = (unsigned int)jarg2;
32063   if (arg1) (arg1)->numberOfTouches = arg2;
32064 }
32065
32066
32067 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_get(void * jarg1) {
32068   unsigned int jresult ;
32069   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32070   unsigned int result;
32071
32072   arg1 = (Dali::LongPressGesture *)jarg1;
32073   result = (unsigned int) ((arg1)->numberOfTouches);
32074   jresult = result;
32075   return jresult;
32076 }
32077
32078
32079 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_set(void * jarg1, void * jarg2) {
32080   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32081   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
32082
32083   arg1 = (Dali::LongPressGesture *)jarg1;
32084   arg2 = (Dali::Vector2 *)jarg2;
32085   if (arg1) (arg1)->screenPoint = *arg2;
32086 }
32087
32088
32089 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_get(void * jarg1) {
32090   void * jresult ;
32091   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32092   Dali::Vector2 *result = 0 ;
32093
32094   arg1 = (Dali::LongPressGesture *)jarg1;
32095   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
32096   jresult = (void *)result;
32097   return jresult;
32098 }
32099
32100
32101 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_set(void * jarg1, void * jarg2) {
32102   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32103   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
32104
32105   arg1 = (Dali::LongPressGesture *)jarg1;
32106   arg2 = (Dali::Vector2 *)jarg2;
32107   if (arg1) (arg1)->localPoint = *arg2;
32108 }
32109
32110
32111 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_get(void * jarg1) {
32112   void * jresult ;
32113   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32114   Dali::Vector2 *result = 0 ;
32115
32116   arg1 = (Dali::LongPressGesture *)jarg1;
32117   result = (Dali::Vector2 *)& ((arg1)->localPoint);
32118   jresult = (void *)result;
32119   return jresult;
32120 }
32121
32122
32123 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_0() {
32124   void * jresult ;
32125   Dali::WheelEvent *result = 0 ;
32126
32127   {
32128     try {
32129       result = (Dali::WheelEvent *)new Dali::WheelEvent();
32130     } catch (std::out_of_range& e) {
32131       {
32132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32133       };
32134     } catch (std::exception& e) {
32135       {
32136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32137       };
32138     } catch (Dali::DaliException e) {
32139       {
32140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32141       };
32142     } catch (...) {
32143       {
32144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32145       };
32146     }
32147   }
32148
32149   jresult = (void *)result;
32150   return jresult;
32151 }
32152
32153
32154 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_1(int jarg1, int jarg2, unsigned int jarg3, void * jarg4, int jarg5, unsigned int jarg6) {
32155   void * jresult ;
32156   Dali::WheelEvent::Type arg1 ;
32157   int arg2 ;
32158   unsigned int arg3 ;
32159   Dali::Vector2 arg4 ;
32160   int arg5 ;
32161   unsigned int arg6 ;
32162   Dali::Vector2 *argp4 ;
32163   Dali::WheelEvent *result = 0 ;
32164
32165   arg1 = (Dali::WheelEvent::Type)jarg1;
32166   arg2 = (int)jarg2;
32167   arg3 = (unsigned int)jarg3;
32168   argp4 = (Dali::Vector2 *)jarg4;
32169   if (!argp4) {
32170     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
32171     return 0;
32172   }
32173   arg4 = *argp4;
32174   arg5 = (int)jarg5;
32175   arg6 = (unsigned int)jarg6;
32176   {
32177     try {
32178       result = (Dali::WheelEvent *)new Dali::WheelEvent(arg1,arg2,arg3,arg4,arg5,arg6);
32179     } catch (std::out_of_range& e) {
32180       {
32181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32182       };
32183     } catch (std::exception& e) {
32184       {
32185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32186       };
32187     } catch (Dali::DaliException e) {
32188       {
32189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32190       };
32191     } catch (...) {
32192       {
32193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32194       };
32195     }
32196   }
32197
32198   jresult = (void *)result;
32199   return jresult;
32200 }
32201
32202
32203 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Wheel(void * jarg1) {
32204   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32205
32206   arg1 = (Dali::WheelEvent *)jarg1;
32207   {
32208     try {
32209       delete arg1;
32210     } catch (std::out_of_range& e) {
32211       {
32212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32213       };
32214     } catch (std::exception& e) {
32215       {
32216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32217       };
32218     } catch (Dali::DaliException e) {
32219       {
32220         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32221       };
32222     } catch (...) {
32223       {
32224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32225       };
32226     }
32227   }
32228
32229 }
32230
32231
32232 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsShiftModifier(void * jarg1) {
32233   unsigned int jresult ;
32234   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32235   bool result;
32236
32237   arg1 = (Dali::WheelEvent *)jarg1;
32238   {
32239     try {
32240       result = (bool)((Dali::WheelEvent const *)arg1)->IsShiftModifier();
32241     } catch (std::out_of_range& e) {
32242       {
32243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32244       };
32245     } catch (std::exception& e) {
32246       {
32247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32248       };
32249     } catch (Dali::DaliException e) {
32250       {
32251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32252       };
32253     } catch (...) {
32254       {
32255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32256       };
32257     }
32258   }
32259
32260   jresult = result;
32261   return jresult;
32262 }
32263
32264
32265 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsCtrlModifier(void * jarg1) {
32266   unsigned int jresult ;
32267   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32268   bool result;
32269
32270   arg1 = (Dali::WheelEvent *)jarg1;
32271   {
32272     try {
32273       result = (bool)((Dali::WheelEvent const *)arg1)->IsCtrlModifier();
32274     } catch (std::out_of_range& e) {
32275       {
32276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32277       };
32278     } catch (std::exception& e) {
32279       {
32280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32281       };
32282     } catch (Dali::DaliException e) {
32283       {
32284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32285       };
32286     } catch (...) {
32287       {
32288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32289       };
32290     }
32291   }
32292
32293   jresult = result;
32294   return jresult;
32295 }
32296
32297
32298 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsAltModifier(void * jarg1) {
32299   unsigned int jresult ;
32300   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32301   bool result;
32302
32303   arg1 = (Dali::WheelEvent *)jarg1;
32304   {
32305     try {
32306       result = (bool)((Dali::WheelEvent const *)arg1)->IsAltModifier();
32307     } catch (std::out_of_range& e) {
32308       {
32309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32310       };
32311     } catch (std::exception& e) {
32312       {
32313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32314       };
32315     } catch (Dali::DaliException e) {
32316       {
32317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32318       };
32319     } catch (...) {
32320       {
32321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32322       };
32323     }
32324   }
32325
32326   jresult = result;
32327   return jresult;
32328 }
32329
32330
32331 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_type_set(void * jarg1, int jarg2) {
32332   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32333   Dali::WheelEvent::Type arg2 ;
32334
32335   arg1 = (Dali::WheelEvent *)jarg1;
32336   arg2 = (Dali::WheelEvent::Type)jarg2;
32337   if (arg1) (arg1)->type = arg2;
32338 }
32339
32340
32341 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_type_get(void * jarg1) {
32342   int jresult ;
32343   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32344   Dali::WheelEvent::Type result;
32345
32346   arg1 = (Dali::WheelEvent *)jarg1;
32347   result = (Dali::WheelEvent::Type) ((arg1)->type);
32348   jresult = (int)result;
32349   return jresult;
32350 }
32351
32352
32353 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_direction_set(void * jarg1, int jarg2) {
32354   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32355   int arg2 ;
32356
32357   arg1 = (Dali::WheelEvent *)jarg1;
32358   arg2 = (int)jarg2;
32359   if (arg1) (arg1)->direction = arg2;
32360 }
32361
32362
32363 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_direction_get(void * jarg1) {
32364   int jresult ;
32365   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32366   int result;
32367
32368   arg1 = (Dali::WheelEvent *)jarg1;
32369   result = (int) ((arg1)->direction);
32370   jresult = result;
32371   return jresult;
32372 }
32373
32374
32375 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_modifiers_set(void * jarg1, unsigned int jarg2) {
32376   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32377   unsigned int arg2 ;
32378
32379   arg1 = (Dali::WheelEvent *)jarg1;
32380   arg2 = (unsigned int)jarg2;
32381   if (arg1) (arg1)->modifiers = arg2;
32382 }
32383
32384
32385 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_modifiers_get(void * jarg1) {
32386   unsigned int jresult ;
32387   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32388   unsigned int result;
32389
32390   arg1 = (Dali::WheelEvent *)jarg1;
32391   result = (unsigned int) ((arg1)->modifiers);
32392   jresult = result;
32393   return jresult;
32394 }
32395
32396
32397 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_point_set(void * jarg1, void * jarg2) {
32398   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32399   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
32400
32401   arg1 = (Dali::WheelEvent *)jarg1;
32402   arg2 = (Dali::Vector2 *)jarg2;
32403   if (arg1) (arg1)->point = *arg2;
32404 }
32405
32406
32407 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_point_get(void * jarg1) {
32408   void * jresult ;
32409   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32410   Dali::Vector2 *result = 0 ;
32411
32412   arg1 = (Dali::WheelEvent *)jarg1;
32413   result = (Dali::Vector2 *)& ((arg1)->point);
32414   jresult = (void *)result;
32415   return jresult;
32416 }
32417
32418
32419 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_z_set(void * jarg1, int jarg2) {
32420   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32421   int arg2 ;
32422
32423   arg1 = (Dali::WheelEvent *)jarg1;
32424   arg2 = (int)jarg2;
32425   if (arg1) (arg1)->z = arg2;
32426 }
32427
32428
32429 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_z_get(void * jarg1) {
32430   int jresult ;
32431   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32432   int result;
32433
32434   arg1 = (Dali::WheelEvent *)jarg1;
32435   result = (int) ((arg1)->z);
32436   jresult = result;
32437   return jresult;
32438 }
32439
32440
32441 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_set(void * jarg1, unsigned int jarg2) {
32442   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32443   unsigned int arg2 ;
32444
32445   arg1 = (Dali::WheelEvent *)jarg1;
32446   arg2 = (unsigned int)jarg2;
32447   if (arg1) (arg1)->timeStamp = arg2;
32448 }
32449
32450
32451 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_get(void * jarg1) {
32452   unsigned int jresult ;
32453   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32454   unsigned int result;
32455
32456   arg1 = (Dali::WheelEvent *)jarg1;
32457   result = (unsigned int) ((arg1)->timeStamp);
32458   jresult = result;
32459   return jresult;
32460 }
32461
32462 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetDeviceName(void * jarg1) {
32463   char * jresult ;
32464   Dali::KeyEvent *arg1 = 0 ;
32465   std::string result;
32466
32467   arg1 = (Dali::KeyEvent *)jarg1;
32468   if (!arg1) {
32469     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32470     return 0;
32471   }
32472   {
32473     try {
32474       result = arg1->GetDeviceName();
32475     } catch (std::out_of_range& e) {
32476       {
32477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32478       };
32479     } catch (std::exception& e) {
32480       {
32481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32482       };
32483     } catch (Dali::DaliException e) {
32484       {
32485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32486       };
32487     } catch (...) {
32488       {
32489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32490       };
32491     }
32492   }
32493
32494   jresult = SWIG_csharp_string_callback((&result)->c_str());
32495   return jresult;
32496 }
32497
32498 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceClass(void * jarg1) {
32499   int jresult ;
32500   Dali::KeyEvent *arg1 = 0 ;
32501   Dali::Device::Class::Type result;
32502
32503   arg1 = (Dali::KeyEvent *)jarg1;
32504   if (!arg1) {
32505     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32506     return 0;
32507   }
32508   {
32509     try {
32510       result = (Dali::Device::Class::Type)arg1->GetDeviceClass();
32511     } catch (std::out_of_range& e) {
32512       {
32513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32514       };
32515     } catch (std::exception& e) {
32516       {
32517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32518       };
32519     } catch (Dali::DaliException e) {
32520       {
32521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32522       };
32523     } catch (...) {
32524       {
32525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32526       };
32527     }
32528   }
32529
32530   jresult = (int)result;
32531   return jresult;
32532 }
32533
32534 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceSubClass(void * jarg1) {
32535   int jresult ;
32536   Dali::KeyEvent *arg1 = 0 ;
32537   Dali::Device::Subclass::Type result;
32538
32539   arg1 = (Dali::KeyEvent *)jarg1;
32540   if (!arg1) {
32541     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32542     return 0;
32543   }
32544   {
32545     try {
32546       result = (Dali::Device::Subclass::Type)arg1->GetDeviceSubclass();
32547     } catch (std::out_of_range& e) {
32548       {
32549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32550       };
32551     } catch (std::exception& e) {
32552       {
32553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32554       };
32555     } catch (Dali::DaliException e) {
32556       {
32557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32558       };
32559     } catch (...) {
32560       {
32561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32562       };
32563     }
32564   }
32565
32566   jresult = (int)result;
32567   return jresult;
32568 }
32569
32570 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Raise(void * jarg1) {
32571   Dali::Actor arg1 ;
32572   Dali::Actor *argp1 ;
32573
32574   argp1 = (Dali::Actor *)jarg1;
32575   if (!argp1) {
32576     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32577     return ;
32578   }
32579   arg1 = *argp1;
32580   {
32581     try {
32582       arg1.Raise();
32583     } catch (std::out_of_range& e) {
32584       {
32585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32586       };
32587     } catch (std::exception& e) {
32588       {
32589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32590       };
32591     } catch (Dali::DaliException e) {
32592       {
32593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32594       };
32595     } catch (...) {
32596       {
32597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32598       };
32599     }
32600   }
32601
32602 }
32603
32604
32605 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Lower(void * jarg1) {
32606   Dali::Actor arg1 ;
32607   Dali::Actor *argp1 ;
32608
32609   argp1 = (Dali::Actor *)jarg1;
32610   if (!argp1) {
32611     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32612     return ;
32613   }
32614   arg1 = *argp1;
32615   {
32616     try {
32617       arg1.Lower();
32618     } catch (std::out_of_range& e) {
32619       {
32620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32621       };
32622     } catch (std::exception& e) {
32623       {
32624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32625       };
32626     } catch (Dali::DaliException e) {
32627       {
32628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32629       };
32630     } catch (...) {
32631       {
32632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32633       };
32634     }
32635   }
32636
32637 }
32638
32639
32640 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseToTop(void * jarg1) {
32641   Dali::Actor arg1 ;
32642   Dali::Actor *argp1 ;
32643
32644   argp1 = (Dali::Actor *)jarg1;
32645   if (!argp1) {
32646     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32647     return ;
32648   }
32649   arg1 = *argp1;
32650   {
32651     try {
32652       arg1.RaiseToTop();
32653     } catch (std::out_of_range& e) {
32654       {
32655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32656       };
32657     } catch (std::exception& e) {
32658       {
32659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32660       };
32661     } catch (Dali::DaliException e) {
32662       {
32663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32664       };
32665     } catch (...) {
32666       {
32667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32668       };
32669     }
32670   }
32671
32672 }
32673
32674
32675 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerToBottom(void * jarg1) {
32676   Dali::Actor arg1 ;
32677   Dali::Actor *argp1 ;
32678
32679   argp1 = (Dali::Actor *)jarg1;
32680   if (!argp1) {
32681     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32682     return ;
32683   }
32684   arg1 = *argp1;
32685   {
32686     try {
32687       arg1.LowerToBottom();
32688     } catch (std::out_of_range& e) {
32689       {
32690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32691       };
32692     } catch (std::exception& e) {
32693       {
32694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32695       };
32696     } catch (Dali::DaliException e) {
32697       {
32698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32699       };
32700     } catch (...) {
32701       {
32702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32703       };
32704     }
32705   }
32706
32707 }
32708
32709
32710 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseAbove(void * jarg1, void * jarg2) {
32711   Dali::Actor arg1 ;
32712   Dali::Actor arg2 ;
32713   Dali::Actor *argp1 ;
32714   Dali::Actor *argp2 ;
32715
32716   argp1 = (Dali::Actor *)jarg1;
32717   if (!argp1) {
32718     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32719     return ;
32720   }
32721   arg1 = *argp1;
32722   argp2 = (Dali::Actor *)jarg2;
32723   if (!argp2) {
32724     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32725     return ;
32726   }
32727   arg2 = *argp2;
32728   {
32729     try {
32730       arg1.RaiseAbove(arg2);
32731     } catch (std::out_of_range& e) {
32732       {
32733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32734       };
32735     } catch (std::exception& e) {
32736       {
32737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32738       };
32739     } catch (Dali::DaliException e) {
32740       {
32741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32742       };
32743     } catch (...) {
32744       {
32745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32746       };
32747     }
32748   }
32749
32750 }
32751
32752
32753 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerBelow(void * jarg1, void * jarg2) {
32754   Dali::Actor arg1 ;
32755   Dali::Actor arg2 ;
32756   Dali::Actor *argp1 ;
32757   Dali::Actor *argp2 ;
32758
32759   argp1 = (Dali::Actor *)jarg1;
32760   if (!argp1) {
32761     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32762     return ;
32763   }
32764   arg1 = *argp1;
32765   argp2 = (Dali::Actor *)jarg2;
32766   if (!argp2) {
32767     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32768     return ;
32769   }
32770   arg2 = *argp2;
32771   {
32772     try {
32773       arg1.LowerBelow(arg2);
32774     } catch (std::out_of_range& e) {
32775       {
32776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32777       };
32778     } catch (std::exception& e) {
32779       {
32780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32781       };
32782     } catch (Dali::DaliException e) {
32783       {
32784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32785       };
32786     } catch (...) {
32787       {
32788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32789       };
32790     }
32791   }
32792
32793 }
32794
32795
32796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisibilityChangedSignal(void * jarg1) {
32797   void * jresult ;
32798   Dali::Actor arg1 ;
32799   Dali::Actor *argp1 ;
32800   Dali::DevelActor::VisibilityChangedSignalType *result = 0 ;
32801
32802   argp1 = (Dali::Actor *)jarg1;
32803   if (!argp1) {
32804     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32805     return 0;
32806   }
32807   arg1 = *argp1;
32808   {
32809     try {
32810       result = (Dali::DevelActor::VisibilityChangedSignalType *) &Dali::DevelActor::VisibilityChangedSignal(arg1);
32811     } catch (std::out_of_range& e) {
32812       {
32813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32814       };
32815     } catch (std::exception& e) {
32816       {
32817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32818       };
32819     } catch (Dali::DaliException e) {
32820       {
32821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32822       };
32823     } catch (...) {
32824       {
32825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32826       };
32827     }
32828   }
32829
32830   jresult = (void *)result;
32831   return jresult;
32832 }
32833
32834
32835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutDirectionChangedSignal(void * jarg1) {
32836   void * jresult ;
32837   Dali::Actor *arg1 ;
32838   Dali::Actor::LayoutDirectionChangedSignalType *result = 0 ;
32839
32840   arg1 = (Dali::Actor *)jarg1;
32841   {
32842     try {
32843       result = (Dali::Actor::LayoutDirectionChangedSignalType *) &(arg1)->LayoutDirectionChangedSignal();
32844     } catch (std::out_of_range& e) {
32845       {
32846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32847       };
32848     } catch (std::exception& e) {
32849       {
32850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32851       };
32852     } catch (Dali::DaliException e) {
32853       {
32854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32855       };
32856     } catch (...) {
32857       {
32858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32859       };
32860     }
32861   }
32862
32863   jresult = (void *)result;
32864   return jresult;
32865 }
32866
32867
32868 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_get() {
32869   int jresult ;
32870   int result;
32871
32872   result = (int)Dali::Actor::Property::PARENT_ORIGIN;
32873   jresult = (int)result;
32874   return jresult;
32875 }
32876
32877
32878 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_X_get() {
32879   int jresult ;
32880   int result;
32881
32882   result = (int)Dali::Actor::Property::PARENT_ORIGIN_X;
32883   jresult = (int)result;
32884   return jresult;
32885 }
32886
32887
32888 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Y_get() {
32889   int jresult ;
32890   int result;
32891
32892   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Y;
32893   jresult = (int)result;
32894   return jresult;
32895 }
32896
32897
32898 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Z_get() {
32899   int jresult ;
32900   int result;
32901
32902   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Z;
32903   jresult = (int)result;
32904   return jresult;
32905 }
32906
32907
32908 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_get() {
32909   int jresult ;
32910   int result;
32911
32912   result = (int)Dali::Actor::Property::ANCHOR_POINT;
32913   jresult = (int)result;
32914   return jresult;
32915 }
32916
32917
32918 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_X_get() {
32919   int jresult ;
32920   int result;
32921
32922   result = (int)Dali::Actor::Property::ANCHOR_POINT_X;
32923   jresult = (int)result;
32924   return jresult;
32925 }
32926
32927
32928 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Y_get() {
32929   int jresult ;
32930   int result;
32931
32932   result = (int)Dali::Actor::Property::ANCHOR_POINT_Y;
32933   jresult = (int)result;
32934   return jresult;
32935 }
32936
32937
32938 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Z_get() {
32939   int jresult ;
32940   int result;
32941
32942   result = (int)Dali::Actor::Property::ANCHOR_POINT_Z;
32943   jresult = (int)result;
32944   return jresult;
32945 }
32946
32947
32948 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_get() {
32949   int jresult ;
32950   int result;
32951
32952   result = (int)Dali::Actor::Property::SIZE;
32953   jresult = (int)result;
32954   return jresult;
32955 }
32956
32957
32958 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_WIDTH_get() {
32959   int jresult ;
32960   int result;
32961
32962   result = (int)Dali::Actor::Property::SIZE_WIDTH;
32963   jresult = (int)result;
32964   return jresult;
32965 }
32966
32967
32968 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_HEIGHT_get() {
32969   int jresult ;
32970   int result;
32971
32972   result = (int)Dali::Actor::Property::SIZE_HEIGHT;
32973   jresult = (int)result;
32974   return jresult;
32975 }
32976
32977
32978 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_DEPTH_get() {
32979   int jresult ;
32980   int result;
32981
32982   result = (int)Dali::Actor::Property::SIZE_DEPTH;
32983   jresult = (int)result;
32984   return jresult;
32985 }
32986
32987
32988 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_get() {
32989   int jresult ;
32990   int result;
32991
32992   result = (int)Dali::Actor::Property::POSITION;
32993   jresult = (int)result;
32994   return jresult;
32995 }
32996
32997
32998 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_X_get() {
32999   int jresult ;
33000   int result;
33001
33002   result = (int)Dali::Actor::Property::POSITION_X;
33003   jresult = (int)result;
33004   return jresult;
33005 }
33006
33007
33008 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Y_get() {
33009   int jresult ;
33010   int result;
33011
33012   result = (int)Dali::Actor::Property::POSITION_Y;
33013   jresult = (int)result;
33014   return jresult;
33015 }
33016
33017
33018 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Z_get() {
33019   int jresult ;
33020   int result;
33021
33022   result = (int)Dali::Actor::Property::POSITION_Z;
33023   jresult = (int)result;
33024   return jresult;
33025 }
33026
33027
33028 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_get() {
33029   int jresult ;
33030   int result;
33031
33032   result = (int)Dali::Actor::Property::WORLD_POSITION;
33033   jresult = (int)result;
33034   return jresult;
33035 }
33036
33037
33038 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_X_get() {
33039   int jresult ;
33040   int result;
33041
33042   result = (int)Dali::Actor::Property::WORLD_POSITION_X;
33043   jresult = (int)result;
33044   return jresult;
33045 }
33046
33047
33048 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Y_get() {
33049   int jresult ;
33050   int result;
33051
33052   result = (int)Dali::Actor::Property::WORLD_POSITION_Y;
33053   jresult = (int)result;
33054   return jresult;
33055 }
33056
33057
33058 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Z_get() {
33059   int jresult ;
33060   int result;
33061
33062   result = (int)Dali::Actor::Property::WORLD_POSITION_Z;
33063   jresult = (int)result;
33064   return jresult;
33065 }
33066
33067
33068 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ORIENTATION_get() {
33069   int jresult ;
33070   int result;
33071
33072   result = (int)Dali::Actor::Property::ORIENTATION;
33073   jresult = (int)result;
33074   return jresult;
33075 }
33076
33077
33078 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_ORIENTATION_get() {
33079   int jresult ;
33080   int result;
33081
33082   result = (int)Dali::Actor::Property::WORLD_ORIENTATION;
33083   jresult = (int)result;
33084   return jresult;
33085 }
33086
33087
33088 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_get() {
33089   int jresult ;
33090   int result;
33091
33092   result = (int)Dali::Actor::Property::SCALE;
33093   jresult = (int)result;
33094   return jresult;
33095 }
33096
33097
33098 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_X_get() {
33099   int jresult ;
33100   int result;
33101
33102   result = (int)Dali::Actor::Property::SCALE_X;
33103   jresult = (int)result;
33104   return jresult;
33105 }
33106
33107
33108 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Y_get() {
33109   int jresult ;
33110   int result;
33111
33112   result = (int)Dali::Actor::Property::SCALE_Y;
33113   jresult = (int)result;
33114   return jresult;
33115 }
33116
33117
33118 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Z_get() {
33119   int jresult ;
33120   int result;
33121
33122   result = (int)Dali::Actor::Property::SCALE_Z;
33123   jresult = (int)result;
33124   return jresult;
33125 }
33126
33127
33128 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_SCALE_get() {
33129   int jresult ;
33130   int result;
33131
33132   result = (int)Dali::Actor::Property::WORLD_SCALE;
33133   jresult = (int)result;
33134   return jresult;
33135 }
33136
33137
33138 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_VISIBLE_get() {
33139   int jresult ;
33140   int result;
33141
33142   result = (int)Dali::Actor::Property::VISIBLE;
33143   jresult = (int)result;
33144   return jresult;
33145 }
33146
33147
33148 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_get() {
33149   int jresult ;
33150   int result;
33151
33152   result = (int)Dali::Actor::Property::COLOR;
33153   jresult = (int)result;
33154   return jresult;
33155 }
33156
33157
33158 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_RED_get() {
33159   int jresult ;
33160   int result;
33161
33162   result = (int)Dali::Actor::Property::COLOR_RED;
33163   jresult = (int)result;
33164   return jresult;
33165 }
33166
33167
33168 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_GREEN_get() {
33169   int jresult ;
33170   int result;
33171
33172   result = (int)Dali::Actor::Property::COLOR_GREEN;
33173   jresult = (int)result;
33174   return jresult;
33175 }
33176
33177
33178 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_BLUE_get() {
33179   int jresult ;
33180   int result;
33181
33182   result = (int)Dali::Actor::Property::COLOR_BLUE;
33183   jresult = (int)result;
33184   return jresult;
33185 }
33186
33187
33188 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_ALPHA_get() {
33189   int jresult ;
33190   int result;
33191
33192   result = (int)Dali::Actor::Property::COLOR_ALPHA;
33193   jresult = (int)result;
33194   return jresult;
33195 }
33196
33197
33198 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_COLOR_get() {
33199   int jresult ;
33200   int result;
33201
33202   result = (int)Dali::Actor::Property::WORLD_COLOR;
33203   jresult = (int)result;
33204   return jresult;
33205 }
33206
33207
33208 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_MATRIX_get() {
33209   int jresult ;
33210   int result;
33211
33212   result = (int)Dali::Actor::Property::WORLD_MATRIX;
33213   jresult = (int)result;
33214   return jresult;
33215 }
33216
33217
33218 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_NAME_get() {
33219   int jresult ;
33220   int result;
33221
33222   result = (int)Dali::Actor::Property::NAME;
33223   jresult = (int)result;
33224   return jresult;
33225 }
33226
33227
33228 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SENSITIVE_get() {
33229   int jresult ;
33230   int result;
33231
33232   result = (int)Dali::Actor::Property::SENSITIVE;
33233   jresult = (int)result;
33234   return jresult;
33235 }
33236
33237
33238 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_LEAVE_REQUIRED_get() {
33239   int jresult ;
33240   int result;
33241
33242   result = (int)Dali::Actor::Property::LEAVE_REQUIRED;
33243   jresult = (int)result;
33244   return jresult;
33245 }
33246
33247
33248 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_ORIENTATION_get() {
33249   int jresult ;
33250   int result;
33251
33252   result = (int)Dali::Actor::Property::INHERIT_ORIENTATION;
33253   jresult = (int)result;
33254   return jresult;
33255 }
33256
33257
33258 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_SCALE_get() {
33259   int jresult ;
33260   int result;
33261
33262   result = (int)Dali::Actor::Property::INHERIT_SCALE;
33263   jresult = (int)result;
33264   return jresult;
33265 }
33266
33267
33268 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_MODE_get() {
33269   int jresult ;
33270   int result;
33271
33272   result = (int)Dali::Actor::Property::COLOR_MODE;
33273   jresult = (int)result;
33274   return jresult;
33275 }
33276
33277
33278 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_INHERITANCE_get() {
33279   int jresult ;
33280   int result;
33281
33282   result = (int)Dali::Actor::Property::POSITION_INHERITANCE;
33283   jresult = (int)result;
33284   return jresult;
33285 }
33286
33287
33288 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_DRAW_MODE_get() {
33289   int jresult ;
33290   int result;
33291
33292   result = (int)Dali::Actor::Property::DRAW_MODE;
33293   jresult = (int)result;
33294   return jresult;
33295 }
33296
33297
33298 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_MODE_FACTOR_get() {
33299   int jresult ;
33300   int result;
33301
33302   result = (int)Dali::Actor::Property::SIZE_MODE_FACTOR;
33303   jresult = (int)result;
33304   return jresult;
33305 }
33306
33307
33308 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_RESIZE_POLICY_get() {
33309   int jresult ;
33310   int result;
33311
33312   result = (int)Dali::Actor::Property::WIDTH_RESIZE_POLICY;
33313   jresult = (int)result;
33314   return jresult;
33315 }
33316
33317
33318 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_RESIZE_POLICY_get() {
33319   int jresult ;
33320   int result;
33321
33322   result = (int)Dali::Actor::Property::HEIGHT_RESIZE_POLICY;
33323   jresult = (int)result;
33324   return jresult;
33325 }
33326
33327
33328 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_SCALE_POLICY_get() {
33329   int jresult ;
33330   int result;
33331
33332   result = (int)Dali::Actor::Property::SIZE_SCALE_POLICY;
33333   jresult = (int)result;
33334   return jresult;
33335 }
33336
33337
33338 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_FOR_HEIGHT_get() {
33339   int jresult ;
33340   int result;
33341
33342   result = (int)Dali::Actor::Property::WIDTH_FOR_HEIGHT;
33343   jresult = (int)result;
33344   return jresult;
33345 }
33346
33347
33348 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_FOR_WIDTH_get() {
33349   int jresult ;
33350   int result;
33351
33352   result = (int)Dali::Actor::Property::HEIGHT_FOR_WIDTH;
33353   jresult = (int)result;
33354   return jresult;
33355 }
33356
33357
33358 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PADDING_get() {
33359   int jresult ;
33360   int result;
33361
33362   result = (int)Dali::Actor::Property::PADDING;
33363   jresult = (int)result;
33364   return jresult;
33365 }
33366
33367
33368 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MINIMUM_SIZE_get() {
33369   int jresult ;
33370   int result;
33371
33372   result = (int)Dali::Actor::Property::MINIMUM_SIZE;
33373   jresult = (int)result;
33374   return jresult;
33375 }
33376
33377
33378 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MAXIMUM_SIZE_get() {
33379   int jresult ;
33380   int result;
33381
33382   result = (int)Dali::Actor::Property::MAXIMUM_SIZE;
33383   jresult = (int)result;
33384   return jresult;
33385 }
33386
33387
33388 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_POSITION_get() {
33389   int jresult ;
33390   int result;
33391
33392   result = (int)Dali::Actor::Property::INHERIT_POSITION;
33393   jresult = (int)result;
33394   return jresult;
33395 }
33396
33397
33398 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_CLIPPING_MODE_get() {
33399   int jresult ;
33400   int result;
33401
33402   result = (int)Dali::Actor::Property::CLIPPING_MODE;
33403   jresult = (int)result;
33404   return jresult;
33405 }
33406
33407
33408 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor_Property() {
33409   void * jresult ;
33410   Dali::Actor::Property *result = 0 ;
33411
33412   {
33413     try {
33414       result = (Dali::Actor::Property *)new Dali::Actor::Property();
33415     } catch (std::out_of_range& e) {
33416       {
33417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33418       };
33419     } catch (std::exception& e) {
33420       {
33421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33422       };
33423     } catch (Dali::DaliException e) {
33424       {
33425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33426       };
33427     } catch (...) {
33428       {
33429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33430       };
33431     }
33432   }
33433
33434   jresult = (void *)result;
33435   return jresult;
33436 }
33437
33438
33439 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor_Property(void * jarg1) {
33440   Dali::Actor::Property *arg1 = (Dali::Actor::Property *) 0 ;
33441
33442   arg1 = (Dali::Actor::Property *)jarg1;
33443   {
33444     try {
33445       delete arg1;
33446     } catch (std::out_of_range& e) {
33447       {
33448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33449       };
33450     } catch (std::exception& e) {
33451       {
33452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33453       };
33454     } catch (Dali::DaliException e) {
33455       {
33456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33457       };
33458     } catch (...) {
33459       {
33460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33461       };
33462     }
33463   }
33464
33465 }
33466
33467
33468 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_0() {
33469   void * jresult ;
33470   Dali::Actor *result = 0 ;
33471
33472   {
33473     try {
33474       result = (Dali::Actor *)new Dali::Actor();
33475     } catch (std::out_of_range& e) {
33476       {
33477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33478       };
33479     } catch (std::exception& e) {
33480       {
33481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33482       };
33483     } catch (Dali::DaliException e) {
33484       {
33485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33486       };
33487     } catch (...) {
33488       {
33489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33490       };
33491     }
33492   }
33493
33494   jresult = (void *)result;
33495   return jresult;
33496 }
33497
33498
33499 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_New() {
33500   void * jresult ;
33501   Dali::Actor result;
33502
33503   {
33504     try {
33505       result = Dali::Actor::New();
33506     } catch (std::out_of_range& e) {
33507       {
33508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33509       };
33510     } catch (std::exception& e) {
33511       {
33512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33513       };
33514     } catch (Dali::DaliException e) {
33515       {
33516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33517       };
33518     } catch (...) {
33519       {
33520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33521       };
33522     }
33523   }
33524
33525   jresult = new Dali::Actor((const Dali::Actor &)result);
33526   return jresult;
33527 }
33528
33529
33530 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_DownCast(void * jarg1) {
33531   void * jresult ;
33532   Dali::BaseHandle arg1 ;
33533   Dali::BaseHandle *argp1 ;
33534   Dali::Actor result;
33535
33536   argp1 = (Dali::BaseHandle *)jarg1;
33537   if (!argp1) {
33538     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
33539     return 0;
33540   }
33541   arg1 = *argp1;
33542   {
33543     try {
33544       result = Dali::Actor::DownCast(arg1);
33545     } catch (std::out_of_range& e) {
33546       {
33547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33548       };
33549     } catch (std::exception& e) {
33550       {
33551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33552       };
33553     } catch (Dali::DaliException e) {
33554       {
33555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33556       };
33557     } catch (...) {
33558       {
33559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33560       };
33561     }
33562   }
33563
33564   jresult = new Dali::Actor((const Dali::Actor &)result);
33565   return jresult;
33566 }
33567
33568
33569 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor(void * jarg1) {
33570   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33571
33572   arg1 = (Dali::Actor *)jarg1;
33573   {
33574     try {
33575       delete arg1;
33576     } catch (std::out_of_range& e) {
33577       {
33578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33579       };
33580     } catch (std::exception& e) {
33581       {
33582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33583       };
33584     } catch (Dali::DaliException e) {
33585       {
33586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33587       };
33588     } catch (...) {
33589       {
33590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33591       };
33592     }
33593   }
33594
33595 }
33596
33597
33598 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_1(void * jarg1) {
33599   void * jresult ;
33600   Dali::Actor *arg1 = 0 ;
33601   Dali::Actor *result = 0 ;
33602
33603   arg1 = (Dali::Actor *)jarg1;
33604   if (!arg1) {
33605     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
33606     return 0;
33607   }
33608   {
33609     try {
33610       result = (Dali::Actor *)new Dali::Actor((Dali::Actor const &)*arg1);
33611     } catch (std::out_of_range& e) {
33612       {
33613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33614       };
33615     } catch (std::exception& e) {
33616       {
33617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33618       };
33619     } catch (Dali::DaliException e) {
33620       {
33621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33622       };
33623     } catch (...) {
33624       {
33625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33626       };
33627     }
33628   }
33629
33630   jresult = (void *)result;
33631   return jresult;
33632 }
33633
33634
33635 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_Assign(void * jarg1, void * jarg2) {
33636   void * jresult ;
33637   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33638   Dali::Actor *arg2 = 0 ;
33639   Dali::Actor *result = 0 ;
33640
33641   arg1 = (Dali::Actor *)jarg1;
33642   arg2 = (Dali::Actor *)jarg2;
33643   if (!arg2) {
33644     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
33645     return 0;
33646   }
33647   {
33648     try {
33649       result = (Dali::Actor *) &(arg1)->operator =((Dali::Actor const &)*arg2);
33650     } catch (std::out_of_range& e) {
33651       {
33652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33653       };
33654     } catch (std::exception& e) {
33655       {
33656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33657       };
33658     } catch (Dali::DaliException e) {
33659       {
33660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33661       };
33662     } catch (...) {
33663       {
33664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33665       };
33666     }
33667   }
33668
33669   jresult = (void *)result;
33670   return jresult;
33671 }
33672
33673
33674 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Actor_GetName(void * jarg1) {
33675   char * jresult ;
33676   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33677   std::string *result = 0 ;
33678
33679   arg1 = (Dali::Actor *)jarg1;
33680   {
33681     try {
33682       result = (std::string *) &((Dali::Actor const *)arg1)->GetName();
33683     } catch (std::out_of_range& e) {
33684       {
33685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33686       };
33687     } catch (std::exception& e) {
33688       {
33689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33690       };
33691     } catch (Dali::DaliException e) {
33692       {
33693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33694       };
33695     } catch (...) {
33696       {
33697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33698       };
33699     }
33700   }
33701
33702   jresult = SWIG_csharp_string_callback(result->c_str());
33703   return jresult;
33704 }
33705
33706
33707 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetName(void * jarg1, char * jarg2) {
33708   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33709   std::string *arg2 = 0 ;
33710
33711   arg1 = (Dali::Actor *)jarg1;
33712   if (!jarg2) {
33713     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
33714     return ;
33715   }
33716   std::string arg2_str(jarg2);
33717   arg2 = &arg2_str;
33718   {
33719     try {
33720       (arg1)->SetName((std::string const &)*arg2);
33721     } catch (std::out_of_range& e) {
33722       {
33723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33724       };
33725     } catch (std::exception& e) {
33726       {
33727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33728       };
33729     } catch (Dali::DaliException e) {
33730       {
33731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33732       };
33733     } catch (...) {
33734       {
33735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33736       };
33737     }
33738   }
33739
33740
33741   //argout typemap for const std::string&
33742
33743 }
33744
33745
33746 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetId(void * jarg1) {
33747   unsigned int jresult ;
33748   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33749   unsigned int result;
33750
33751   arg1 = (Dali::Actor *)jarg1;
33752   {
33753     try {
33754       result = (unsigned int)((Dali::Actor const *)arg1)->GetId();
33755     } catch (std::out_of_range& e) {
33756       {
33757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33758       };
33759     } catch (std::exception& e) {
33760       {
33761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33762       };
33763     } catch (Dali::DaliException e) {
33764       {
33765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33766       };
33767     } catch (...) {
33768       {
33769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33770       };
33771     }
33772   }
33773
33774   jresult = result;
33775   return jresult;
33776 }
33777
33778
33779 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsRoot(void * jarg1) {
33780   unsigned int jresult ;
33781   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33782   bool result;
33783
33784   arg1 = (Dali::Actor *)jarg1;
33785   {
33786     try {
33787       result = (bool)((Dali::Actor const *)arg1)->IsRoot();
33788     } catch (std::out_of_range& e) {
33789       {
33790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33791       };
33792     } catch (std::exception& e) {
33793       {
33794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33795       };
33796     } catch (Dali::DaliException e) {
33797       {
33798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33799       };
33800     } catch (...) {
33801       {
33802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33803       };
33804     }
33805   }
33806
33807   jresult = result;
33808   return jresult;
33809 }
33810
33811
33812 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_OnStage(void * jarg1) {
33813   unsigned int jresult ;
33814   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33815   bool result;
33816
33817   arg1 = (Dali::Actor *)jarg1;
33818   {
33819     try {
33820       result = (bool)((Dali::Actor const *)arg1)->OnStage();
33821     } catch (std::out_of_range& e) {
33822       {
33823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33824       };
33825     } catch (std::exception& e) {
33826       {
33827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33828       };
33829     } catch (Dali::DaliException e) {
33830       {
33831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33832       };
33833     } catch (...) {
33834       {
33835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33836       };
33837     }
33838   }
33839
33840   jresult = result;
33841   return jresult;
33842 }
33843
33844
33845 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsLayer(void * jarg1) {
33846   unsigned int jresult ;
33847   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33848   bool result;
33849
33850   arg1 = (Dali::Actor *)jarg1;
33851   {
33852     try {
33853       result = (bool)((Dali::Actor const *)arg1)->IsLayer();
33854     } catch (std::out_of_range& e) {
33855       {
33856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33857       };
33858     } catch (std::exception& e) {
33859       {
33860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33861       };
33862     } catch (Dali::DaliException e) {
33863       {
33864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33865       };
33866     } catch (...) {
33867       {
33868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33869       };
33870     }
33871   }
33872
33873   jresult = result;
33874   return jresult;
33875 }
33876
33877
33878 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetLayer(void * jarg1) {
33879   void * jresult ;
33880   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33881   Dali::Layer result;
33882
33883   arg1 = (Dali::Actor *)jarg1;
33884   {
33885     try {
33886       result = (arg1)->GetLayer();
33887     } catch (std::out_of_range& e) {
33888       {
33889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33890       };
33891     } catch (std::exception& e) {
33892       {
33893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33894       };
33895     } catch (Dali::DaliException e) {
33896       {
33897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33898       };
33899     } catch (...) {
33900       {
33901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33902       };
33903     }
33904   }
33905
33906   jresult = new Dali::Layer((const Dali::Layer &)result);
33907   return jresult;
33908 }
33909
33910
33911 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Add(void * jarg1, void * jarg2) {
33912   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33913   Dali::Actor arg2 ;
33914   Dali::Actor *argp2 ;
33915
33916   arg1 = (Dali::Actor *)jarg1;
33917   argp2 = (Dali::Actor *)jarg2;
33918   if (!argp2) {
33919     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
33920     return ;
33921   }
33922   arg2 = *argp2;
33923   {
33924     try {
33925       (arg1)->Add(arg2);
33926     } catch (std::out_of_range& e) {
33927       {
33928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33929       };
33930     } catch (std::exception& e) {
33931       {
33932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33933       };
33934     } catch (Dali::DaliException e) {
33935       {
33936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33937       };
33938     } catch (...) {
33939       {
33940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33941       };
33942     }
33943   }
33944
33945 }
33946
33947
33948 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Remove(void * jarg1, void * jarg2) {
33949   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33950   Dali::Actor arg2 ;
33951   Dali::Actor *argp2 ;
33952
33953   arg1 = (Dali::Actor *)jarg1;
33954   argp2 = (Dali::Actor *)jarg2;
33955   if (!argp2) {
33956     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
33957     return ;
33958   }
33959   arg2 = *argp2;
33960   {
33961     try {
33962       (arg1)->Remove(arg2);
33963     } catch (std::out_of_range& e) {
33964       {
33965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33966       };
33967     } catch (std::exception& e) {
33968       {
33969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33970       };
33971     } catch (Dali::DaliException e) {
33972       {
33973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33974       };
33975     } catch (...) {
33976       {
33977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33978       };
33979     }
33980   }
33981
33982 }
33983
33984
33985 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Unparent(void * jarg1) {
33986   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33987
33988   arg1 = (Dali::Actor *)jarg1;
33989   {
33990     try {
33991       (arg1)->Unparent();
33992     } catch (std::out_of_range& e) {
33993       {
33994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33995       };
33996     } catch (std::exception& e) {
33997       {
33998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33999       };
34000     } catch (Dali::DaliException e) {
34001       {
34002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34003       };
34004     } catch (...) {
34005       {
34006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34007       };
34008     }
34009   }
34010
34011 }
34012
34013
34014 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetChildCount(void * jarg1) {
34015   unsigned int jresult ;
34016   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34017   unsigned int result;
34018
34019   arg1 = (Dali::Actor *)jarg1;
34020   {
34021     try {
34022       result = (unsigned int)((Dali::Actor const *)arg1)->GetChildCount();
34023     } catch (std::out_of_range& e) {
34024       {
34025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34026       };
34027     } catch (std::exception& e) {
34028       {
34029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34030       };
34031     } catch (Dali::DaliException e) {
34032       {
34033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34034       };
34035     } catch (...) {
34036       {
34037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34038       };
34039     }
34040   }
34041
34042   jresult = result;
34043   return jresult;
34044 }
34045
34046
34047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetChildAt(void * jarg1, unsigned int jarg2) {
34048   void * jresult ;
34049   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34050   unsigned int arg2 ;
34051   Dali::Actor result;
34052
34053   arg1 = (Dali::Actor *)jarg1;
34054   arg2 = (unsigned int)jarg2;
34055   {
34056     try {
34057       result = ((Dali::Actor const *)arg1)->GetChildAt(arg2);
34058     } catch (std::out_of_range& e) {
34059       {
34060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34061       };
34062     } catch (std::exception& e) {
34063       {
34064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34065       };
34066     } catch (Dali::DaliException e) {
34067       {
34068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34069       };
34070     } catch (...) {
34071       {
34072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34073       };
34074     }
34075   }
34076
34077   jresult = new Dali::Actor((const Dali::Actor &)result);
34078   return jresult;
34079 }
34080
34081
34082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildByName(void * jarg1, char * jarg2) {
34083   void * jresult ;
34084   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34085   std::string *arg2 = 0 ;
34086   Dali::Actor result;
34087
34088   arg1 = (Dali::Actor *)jarg1;
34089   if (!jarg2) {
34090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
34091     return 0;
34092   }
34093   std::string arg2_str(jarg2);
34094   arg2 = &arg2_str;
34095   {
34096     try {
34097       result = (arg1)->FindChildByName((std::string const &)*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
34119   //argout typemap for const std::string&
34120
34121   return jresult;
34122 }
34123
34124
34125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildById(void * jarg1, unsigned int jarg2) {
34126   void * jresult ;
34127   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34128   unsigned int arg2 ;
34129   Dali::Actor result;
34130
34131   arg1 = (Dali::Actor *)jarg1;
34132   arg2 = (unsigned int)jarg2;
34133   {
34134     try {
34135       result = (arg1)->FindChildById(arg2);
34136     } catch (std::out_of_range& e) {
34137       {
34138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34139       };
34140     } catch (std::exception& e) {
34141       {
34142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34143       };
34144     } catch (Dali::DaliException e) {
34145       {
34146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34147       };
34148     } catch (...) {
34149       {
34150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34151       };
34152     }
34153   }
34154
34155   jresult = new Dali::Actor((const Dali::Actor &)result);
34156   return jresult;
34157 }
34158
34159
34160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetParent(void * jarg1) {
34161   void * jresult ;
34162   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34163   Dali::Actor result;
34164
34165   arg1 = (Dali::Actor *)jarg1;
34166   {
34167     try {
34168       result = ((Dali::Actor const *)arg1)->GetParent();
34169     } catch (std::out_of_range& e) {
34170       {
34171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34172       };
34173     } catch (std::exception& e) {
34174       {
34175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34176       };
34177     } catch (Dali::DaliException e) {
34178       {
34179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34180       };
34181     } catch (...) {
34182       {
34183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34184       };
34185     }
34186   }
34187
34188   jresult = new Dali::Actor((const Dali::Actor &)result);
34189   return jresult;
34190 }
34191
34192
34193 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetParentOrigin(void * jarg1, void * jarg2) {
34194   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34195   Dali::Vector3 *arg2 = 0 ;
34196
34197   arg1 = (Dali::Actor *)jarg1;
34198   arg2 = (Dali::Vector3 *)jarg2;
34199   if (!arg2) {
34200     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34201     return ;
34202   }
34203   {
34204     try {
34205       (arg1)->SetParentOrigin((Dali::Vector3 const &)*arg2);
34206     } catch (std::out_of_range& e) {
34207       {
34208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34209       };
34210     } catch (std::exception& e) {
34211       {
34212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34213       };
34214     } catch (Dali::DaliException e) {
34215       {
34216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34217       };
34218     } catch (...) {
34219       {
34220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34221       };
34222     }
34223   }
34224
34225 }
34226
34227
34228 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentParentOrigin(void * jarg1) {
34229   void * jresult ;
34230   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34231   Dali::Vector3 result;
34232
34233   arg1 = (Dali::Actor *)jarg1;
34234   {
34235     try {
34236       result = ((Dali::Actor const *)arg1)->GetCurrentParentOrigin();
34237     } catch (std::out_of_range& e) {
34238       {
34239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34240       };
34241     } catch (std::exception& e) {
34242       {
34243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34244       };
34245     } catch (Dali::DaliException e) {
34246       {
34247         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34248       };
34249     } catch (...) {
34250       {
34251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34252       };
34253     }
34254   }
34255
34256   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34257   return jresult;
34258 }
34259
34260
34261 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetAnchorPoint(void * jarg1, void * jarg2) {
34262   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34263   Dali::Vector3 *arg2 = 0 ;
34264
34265   arg1 = (Dali::Actor *)jarg1;
34266   arg2 = (Dali::Vector3 *)jarg2;
34267   if (!arg2) {
34268     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34269     return ;
34270   }
34271   {
34272     try {
34273       (arg1)->SetAnchorPoint((Dali::Vector3 const &)*arg2);
34274     } catch (std::out_of_range& e) {
34275       {
34276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34277       };
34278     } catch (std::exception& e) {
34279       {
34280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34281       };
34282     } catch (Dali::DaliException e) {
34283       {
34284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34285       };
34286     } catch (...) {
34287       {
34288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34289       };
34290     }
34291   }
34292
34293 }
34294
34295
34296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentAnchorPoint(void * jarg1) {
34297   void * jresult ;
34298   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34299   Dali::Vector3 result;
34300
34301   arg1 = (Dali::Actor *)jarg1;
34302   {
34303     try {
34304       result = ((Dali::Actor const *)arg1)->GetCurrentAnchorPoint();
34305     } catch (std::out_of_range& e) {
34306       {
34307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34308       };
34309     } catch (std::exception& e) {
34310       {
34311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34312       };
34313     } catch (Dali::DaliException e) {
34314       {
34315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34316       };
34317     } catch (...) {
34318       {
34319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34320       };
34321     }
34322   }
34323
34324   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34325   return jresult;
34326 }
34327
34328
34329 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_0(void * jarg1, float jarg2, float jarg3) {
34330   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34331   float arg2 ;
34332   float arg3 ;
34333
34334   arg1 = (Dali::Actor *)jarg1;
34335   arg2 = (float)jarg2;
34336   arg3 = (float)jarg3;
34337   {
34338     try {
34339       (arg1)->SetSize(arg2,arg3);
34340     } catch (std::out_of_range& e) {
34341       {
34342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34343       };
34344     } catch (std::exception& e) {
34345       {
34346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34347       };
34348     } catch (Dali::DaliException e) {
34349       {
34350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34351       };
34352     } catch (...) {
34353       {
34354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34355       };
34356     }
34357   }
34358
34359 }
34360
34361
34362 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
34363   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34364   float arg2 ;
34365   float arg3 ;
34366   float arg4 ;
34367
34368   arg1 = (Dali::Actor *)jarg1;
34369   arg2 = (float)jarg2;
34370   arg3 = (float)jarg3;
34371   arg4 = (float)jarg4;
34372   {
34373     try {
34374       (arg1)->SetSize(arg2,arg3,arg4);
34375     } catch (std::out_of_range& e) {
34376       {
34377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34378       };
34379     } catch (std::exception& e) {
34380       {
34381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34382       };
34383     } catch (Dali::DaliException e) {
34384       {
34385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34386       };
34387     } catch (...) {
34388       {
34389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34390       };
34391     }
34392   }
34393
34394 }
34395
34396
34397 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_2(void * jarg1, void * jarg2) {
34398   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34399   Dali::Vector2 *arg2 = 0 ;
34400
34401   arg1 = (Dali::Actor *)jarg1;
34402   arg2 = (Dali::Vector2 *)jarg2;
34403   if (!arg2) {
34404     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
34405     return ;
34406   }
34407   {
34408     try {
34409       (arg1)->SetSize((Dali::Vector2 const &)*arg2);
34410     } catch (std::out_of_range& e) {
34411       {
34412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34413       };
34414     } catch (std::exception& e) {
34415       {
34416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34417       };
34418     } catch (Dali::DaliException e) {
34419       {
34420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34421       };
34422     } catch (...) {
34423       {
34424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34425       };
34426     }
34427   }
34428
34429 }
34430
34431
34432 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_3(void * jarg1, void * jarg2) {
34433   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34434   Dali::Vector3 *arg2 = 0 ;
34435
34436   arg1 = (Dali::Actor *)jarg1;
34437   arg2 = (Dali::Vector3 *)jarg2;
34438   if (!arg2) {
34439     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34440     return ;
34441   }
34442   {
34443     try {
34444       (arg1)->SetSize((Dali::Vector3 const &)*arg2);
34445     } catch (std::out_of_range& e) {
34446       {
34447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34448       };
34449     } catch (std::exception& e) {
34450       {
34451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34452       };
34453     } catch (Dali::DaliException e) {
34454       {
34455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34456       };
34457     } catch (...) {
34458       {
34459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34460       };
34461     }
34462   }
34463
34464 }
34465
34466
34467 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetTargetSize(void * jarg1) {
34468   void * jresult ;
34469   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34470   Dali::Vector3 result;
34471
34472   arg1 = (Dali::Actor *)jarg1;
34473   {
34474     try {
34475       result = ((Dali::Actor const *)arg1)->GetTargetSize();
34476     } catch (std::out_of_range& e) {
34477       {
34478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34479       };
34480     } catch (std::exception& e) {
34481       {
34482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34483       };
34484     } catch (Dali::DaliException e) {
34485       {
34486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34487       };
34488     } catch (...) {
34489       {
34490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34491       };
34492     }
34493   }
34494
34495   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34496   return jresult;
34497 }
34498
34499
34500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentSize(void * jarg1) {
34501   void * jresult ;
34502   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34503   Dali::Vector3 result;
34504
34505   arg1 = (Dali::Actor *)jarg1;
34506   {
34507     try {
34508       result = ((Dali::Actor const *)arg1)->GetCurrentSize();
34509     } catch (std::out_of_range& e) {
34510       {
34511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34512       };
34513     } catch (std::exception& e) {
34514       {
34515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34516       };
34517     } catch (Dali::DaliException e) {
34518       {
34519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34520       };
34521     } catch (...) {
34522       {
34523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34524       };
34525     }
34526   }
34527
34528   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34529   return jresult;
34530 }
34531
34532
34533 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetNaturalSize(void * jarg1) {
34534   void * jresult ;
34535   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34536   Dali::Vector3 result;
34537
34538   arg1 = (Dali::Actor *)jarg1;
34539   {
34540     try {
34541       result = ((Dali::Actor const *)arg1)->GetNaturalSize();
34542     } catch (std::out_of_range& e) {
34543       {
34544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34545       };
34546     } catch (std::exception& e) {
34547       {
34548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34549       };
34550     } catch (Dali::DaliException e) {
34551       {
34552         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34553       };
34554     } catch (...) {
34555       {
34556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34557       };
34558     }
34559   }
34560
34561   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34562   return jresult;
34563 }
34564
34565
34566 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_0(void * jarg1, float jarg2, float jarg3) {
34567   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34568   float arg2 ;
34569   float arg3 ;
34570
34571   arg1 = (Dali::Actor *)jarg1;
34572   arg2 = (float)jarg2;
34573   arg3 = (float)jarg3;
34574   {
34575     try {
34576       (arg1)->SetPosition(arg2,arg3);
34577     } catch (std::out_of_range& e) {
34578       {
34579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34580       };
34581     } catch (std::exception& e) {
34582       {
34583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34584       };
34585     } catch (Dali::DaliException e) {
34586       {
34587         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34588       };
34589     } catch (...) {
34590       {
34591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34592       };
34593     }
34594   }
34595
34596 }
34597
34598
34599 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
34600   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34601   float arg2 ;
34602   float arg3 ;
34603   float arg4 ;
34604
34605   arg1 = (Dali::Actor *)jarg1;
34606   arg2 = (float)jarg2;
34607   arg3 = (float)jarg3;
34608   arg4 = (float)jarg4;
34609   {
34610     try {
34611       (arg1)->SetPosition(arg2,arg3,arg4);
34612     } catch (std::out_of_range& e) {
34613       {
34614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34615       };
34616     } catch (std::exception& e) {
34617       {
34618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34619       };
34620     } catch (Dali::DaliException e) {
34621       {
34622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34623       };
34624     } catch (...) {
34625       {
34626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34627       };
34628     }
34629   }
34630
34631 }
34632
34633
34634 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_2(void * jarg1, void * jarg2) {
34635   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34636   Dali::Vector3 *arg2 = 0 ;
34637
34638   arg1 = (Dali::Actor *)jarg1;
34639   arg2 = (Dali::Vector3 *)jarg2;
34640   if (!arg2) {
34641     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34642     return ;
34643   }
34644   {
34645     try {
34646       (arg1)->SetPosition((Dali::Vector3 const &)*arg2);
34647     } catch (std::out_of_range& e) {
34648       {
34649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34650       };
34651     } catch (std::exception& e) {
34652       {
34653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34654       };
34655     } catch (Dali::DaliException e) {
34656       {
34657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34658       };
34659     } catch (...) {
34660       {
34661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34662       };
34663     }
34664   }
34665
34666 }
34667
34668
34669 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetX(void * jarg1, float jarg2) {
34670   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34671   float arg2 ;
34672
34673   arg1 = (Dali::Actor *)jarg1;
34674   arg2 = (float)jarg2;
34675   {
34676     try {
34677       (arg1)->SetX(arg2);
34678     } catch (std::out_of_range& e) {
34679       {
34680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34681       };
34682     } catch (std::exception& e) {
34683       {
34684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34685       };
34686     } catch (Dali::DaliException e) {
34687       {
34688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34689       };
34690     } catch (...) {
34691       {
34692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34693       };
34694     }
34695   }
34696
34697 }
34698
34699
34700 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetY(void * jarg1, float jarg2) {
34701   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34702   float arg2 ;
34703
34704   arg1 = (Dali::Actor *)jarg1;
34705   arg2 = (float)jarg2;
34706   {
34707     try {
34708       (arg1)->SetY(arg2);
34709     } catch (std::out_of_range& e) {
34710       {
34711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34712       };
34713     } catch (std::exception& e) {
34714       {
34715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34716       };
34717     } catch (Dali::DaliException e) {
34718       {
34719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34720       };
34721     } catch (...) {
34722       {
34723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34724       };
34725     }
34726   }
34727
34728 }
34729
34730
34731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetZ(void * jarg1, float jarg2) {
34732   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34733   float arg2 ;
34734
34735   arg1 = (Dali::Actor *)jarg1;
34736   arg2 = (float)jarg2;
34737   {
34738     try {
34739       (arg1)->SetZ(arg2);
34740     } catch (std::out_of_range& e) {
34741       {
34742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34743       };
34744     } catch (std::exception& e) {
34745       {
34746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34747       };
34748     } catch (Dali::DaliException e) {
34749       {
34750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34751       };
34752     } catch (...) {
34753       {
34754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34755       };
34756     }
34757   }
34758
34759 }
34760
34761
34762 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_TranslateBy(void * jarg1, void * jarg2) {
34763   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34764   Dali::Vector3 *arg2 = 0 ;
34765
34766   arg1 = (Dali::Actor *)jarg1;
34767   arg2 = (Dali::Vector3 *)jarg2;
34768   if (!arg2) {
34769     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34770     return ;
34771   }
34772   {
34773     try {
34774       (arg1)->TranslateBy((Dali::Vector3 const &)*arg2);
34775     } catch (std::out_of_range& e) {
34776       {
34777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34778       };
34779     } catch (std::exception& e) {
34780       {
34781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34782       };
34783     } catch (Dali::DaliException e) {
34784       {
34785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34786       };
34787     } catch (...) {
34788       {
34789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34790       };
34791     }
34792   }
34793
34794 }
34795
34796
34797 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentPosition(void * jarg1) {
34798   void * jresult ;
34799   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34800   Dali::Vector3 result;
34801
34802   arg1 = (Dali::Actor *)jarg1;
34803   {
34804     try {
34805       result = ((Dali::Actor const *)arg1)->GetCurrentPosition();
34806     } catch (std::out_of_range& e) {
34807       {
34808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34809       };
34810     } catch (std::exception& e) {
34811       {
34812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34813       };
34814     } catch (Dali::DaliException e) {
34815       {
34816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34817       };
34818     } catch (...) {
34819       {
34820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34821       };
34822     }
34823   }
34824
34825   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34826   return jresult;
34827 }
34828
34829
34830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldPosition(void * jarg1) {
34831   void * jresult ;
34832   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34833   Dali::Vector3 result;
34834
34835   arg1 = (Dali::Actor *)jarg1;
34836   {
34837     try {
34838       result = ((Dali::Actor const *)arg1)->GetCurrentWorldPosition();
34839     } catch (std::out_of_range& e) {
34840       {
34841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34842       };
34843     } catch (std::exception& e) {
34844       {
34845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34846       };
34847     } catch (Dali::DaliException e) {
34848       {
34849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34850       };
34851     } catch (...) {
34852       {
34853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34854       };
34855     }
34856   }
34857
34858   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34859   return jresult;
34860 }
34861
34862
34863 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritPosition(void * jarg1, unsigned int jarg2) {
34864   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34865   bool arg2 ;
34866
34867   arg1 = (Dali::Actor *)jarg1;
34868   arg2 = jarg2 ? true : false;
34869   {
34870     try {
34871       (arg1)->SetInheritPosition(arg2);
34872     } catch (std::out_of_range& e) {
34873       {
34874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34875       };
34876     } catch (std::exception& e) {
34877       {
34878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34879       };
34880     } catch (Dali::DaliException e) {
34881       {
34882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34883       };
34884     } catch (...) {
34885       {
34886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34887       };
34888     }
34889   }
34890
34891 }
34892
34893
34894 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetPositionInheritanceMode(void * jarg1) {
34895   int jresult ;
34896   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34897   Dali::PositionInheritanceMode result;
34898
34899   arg1 = (Dali::Actor *)jarg1;
34900   {
34901     try {
34902       result = (Dali::PositionInheritanceMode)((Dali::Actor const *)arg1)->GetPositionInheritanceMode();
34903     } catch (std::out_of_range& e) {
34904       {
34905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34906       };
34907     } catch (std::exception& e) {
34908       {
34909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34910       };
34911     } catch (Dali::DaliException e) {
34912       {
34913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34914       };
34915     } catch (...) {
34916       {
34917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34918       };
34919     }
34920   }
34921
34922   jresult = (int)result;
34923   return jresult;
34924 }
34925
34926
34927 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsPositionInherited(void * jarg1) {
34928   unsigned int jresult ;
34929   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34930   bool result;
34931
34932   arg1 = (Dali::Actor *)jarg1;
34933   {
34934     try {
34935       result = (bool)((Dali::Actor const *)arg1)->IsPositionInherited();
34936     } catch (std::out_of_range& e) {
34937       {
34938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34939       };
34940     } catch (std::exception& e) {
34941       {
34942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34943       };
34944     } catch (Dali::DaliException e) {
34945       {
34946         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34947       };
34948     } catch (...) {
34949       {
34950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34951       };
34952     }
34953   }
34954
34955   jresult = result;
34956   return jresult;
34957 }
34958
34959
34960 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
34961   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34962   Dali::Degree *arg2 = 0 ;
34963   Dali::Vector3 *arg3 = 0 ;
34964
34965   arg1 = (Dali::Actor *)jarg1;
34966   arg2 = (Dali::Degree *)jarg2;
34967   if (!arg2) {
34968     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
34969     return ;
34970   }
34971   arg3 = (Dali::Vector3 *)jarg3;
34972   if (!arg3) {
34973     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34974     return ;
34975   }
34976   {
34977     try {
34978       (arg1)->SetOrientation((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
34979     } catch (std::out_of_range& e) {
34980       {
34981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34982       };
34983     } catch (std::exception& e) {
34984       {
34985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34986       };
34987     } catch (Dali::DaliException e) {
34988       {
34989         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34990       };
34991     } catch (...) {
34992       {
34993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34994       };
34995     }
34996   }
34997
34998 }
34999
35000
35001 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
35002   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35003   Dali::Radian *arg2 = 0 ;
35004   Dali::Vector3 *arg3 = 0 ;
35005
35006   arg1 = (Dali::Actor *)jarg1;
35007   arg2 = (Dali::Radian *)jarg2;
35008   if (!arg2) {
35009     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
35010     return ;
35011   }
35012   arg3 = (Dali::Vector3 *)jarg3;
35013   if (!arg3) {
35014     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35015     return ;
35016   }
35017   {
35018     try {
35019       (arg1)->SetOrientation((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
35020     } catch (std::out_of_range& e) {
35021       {
35022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35023       };
35024     } catch (std::exception& e) {
35025       {
35026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35027       };
35028     } catch (Dali::DaliException e) {
35029       {
35030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35031       };
35032     } catch (...) {
35033       {
35034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35035       };
35036     }
35037   }
35038
35039 }
35040
35041
35042 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_2(void * jarg1, void * jarg2) {
35043   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35044   Dali::Quaternion *arg2 = 0 ;
35045
35046   arg1 = (Dali::Actor *)jarg1;
35047   arg2 = (Dali::Quaternion *)jarg2;
35048   if (!arg2) {
35049     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
35050     return ;
35051   }
35052   {
35053     try {
35054       (arg1)->SetOrientation((Dali::Quaternion const &)*arg2);
35055     } catch (std::out_of_range& e) {
35056       {
35057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35058       };
35059     } catch (std::exception& e) {
35060       {
35061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35062       };
35063     } catch (Dali::DaliException e) {
35064       {
35065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35066       };
35067     } catch (...) {
35068       {
35069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35070       };
35071     }
35072   }
35073
35074 }
35075
35076
35077 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
35078   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35079   Dali::Degree *arg2 = 0 ;
35080   Dali::Vector3 *arg3 = 0 ;
35081
35082   arg1 = (Dali::Actor *)jarg1;
35083   arg2 = (Dali::Degree *)jarg2;
35084   if (!arg2) {
35085     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
35086     return ;
35087   }
35088   arg3 = (Dali::Vector3 *)jarg3;
35089   if (!arg3) {
35090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35091     return ;
35092   }
35093   {
35094     try {
35095       (arg1)->RotateBy((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
35096     } catch (std::out_of_range& e) {
35097       {
35098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35099       };
35100     } catch (std::exception& e) {
35101       {
35102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35103       };
35104     } catch (Dali::DaliException e) {
35105       {
35106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35107       };
35108     } catch (...) {
35109       {
35110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35111       };
35112     }
35113   }
35114
35115 }
35116
35117
35118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
35119   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35120   Dali::Radian *arg2 = 0 ;
35121   Dali::Vector3 *arg3 = 0 ;
35122
35123   arg1 = (Dali::Actor *)jarg1;
35124   arg2 = (Dali::Radian *)jarg2;
35125   if (!arg2) {
35126     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
35127     return ;
35128   }
35129   arg3 = (Dali::Vector3 *)jarg3;
35130   if (!arg3) {
35131     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35132     return ;
35133   }
35134   {
35135     try {
35136       (arg1)->RotateBy((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
35137     } catch (std::out_of_range& e) {
35138       {
35139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35140       };
35141     } catch (std::exception& e) {
35142       {
35143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35144       };
35145     } catch (Dali::DaliException e) {
35146       {
35147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35148       };
35149     } catch (...) {
35150       {
35151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35152       };
35153     }
35154   }
35155
35156 }
35157
35158
35159 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_2(void * jarg1, void * jarg2) {
35160   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35161   Dali::Quaternion *arg2 = 0 ;
35162
35163   arg1 = (Dali::Actor *)jarg1;
35164   arg2 = (Dali::Quaternion *)jarg2;
35165   if (!arg2) {
35166     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
35167     return ;
35168   }
35169   {
35170     try {
35171       (arg1)->RotateBy((Dali::Quaternion const &)*arg2);
35172     } catch (std::out_of_range& e) {
35173       {
35174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35175       };
35176     } catch (std::exception& e) {
35177       {
35178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35179       };
35180     } catch (Dali::DaliException e) {
35181       {
35182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35183       };
35184     } catch (...) {
35185       {
35186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35187       };
35188     }
35189   }
35190
35191 }
35192
35193
35194 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOrientation(void * jarg1) {
35195   void * jresult ;
35196   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35197   Dali::Quaternion result;
35198
35199   arg1 = (Dali::Actor *)jarg1;
35200   {
35201     try {
35202       result = ((Dali::Actor const *)arg1)->GetCurrentOrientation();
35203     } catch (std::out_of_range& e) {
35204       {
35205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35206       };
35207     } catch (std::exception& e) {
35208       {
35209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35210       };
35211     } catch (Dali::DaliException e) {
35212       {
35213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35214       };
35215     } catch (...) {
35216       {
35217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35218       };
35219     }
35220   }
35221
35222   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
35223   return jresult;
35224 }
35225
35226
35227 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritOrientation(void * jarg1, unsigned int jarg2) {
35228   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35229   bool arg2 ;
35230
35231   arg1 = (Dali::Actor *)jarg1;
35232   arg2 = jarg2 ? true : false;
35233   {
35234     try {
35235       (arg1)->SetInheritOrientation(arg2);
35236     } catch (std::out_of_range& e) {
35237       {
35238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35239       };
35240     } catch (std::exception& e) {
35241       {
35242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35243       };
35244     } catch (Dali::DaliException e) {
35245       {
35246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35247       };
35248     } catch (...) {
35249       {
35250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35251       };
35252     }
35253   }
35254
35255 }
35256
35257
35258 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsOrientationInherited(void * jarg1) {
35259   unsigned int jresult ;
35260   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35261   bool result;
35262
35263   arg1 = (Dali::Actor *)jarg1;
35264   {
35265     try {
35266       result = (bool)((Dali::Actor const *)arg1)->IsOrientationInherited();
35267     } catch (std::out_of_range& e) {
35268       {
35269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35270       };
35271     } catch (std::exception& e) {
35272       {
35273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35274       };
35275     } catch (Dali::DaliException e) {
35276       {
35277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35278       };
35279     } catch (...) {
35280       {
35281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35282       };
35283     }
35284   }
35285
35286   jresult = result;
35287   return jresult;
35288 }
35289
35290
35291 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldOrientation(void * jarg1) {
35292   void * jresult ;
35293   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35294   Dali::Quaternion result;
35295
35296   arg1 = (Dali::Actor *)jarg1;
35297   {
35298     try {
35299       result = ((Dali::Actor const *)arg1)->GetCurrentWorldOrientation();
35300     } catch (std::out_of_range& e) {
35301       {
35302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35303       };
35304     } catch (std::exception& e) {
35305       {
35306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35307       };
35308     } catch (Dali::DaliException e) {
35309       {
35310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35311       };
35312     } catch (...) {
35313       {
35314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35315       };
35316     }
35317   }
35318
35319   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
35320   return jresult;
35321 }
35322
35323
35324 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_0(void * jarg1, float jarg2) {
35325   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35326   float arg2 ;
35327
35328   arg1 = (Dali::Actor *)jarg1;
35329   arg2 = (float)jarg2;
35330   {
35331     try {
35332       (arg1)->SetScale(arg2);
35333     } catch (std::out_of_range& e) {
35334       {
35335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35336       };
35337     } catch (std::exception& e) {
35338       {
35339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35340       };
35341     } catch (Dali::DaliException e) {
35342       {
35343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35344       };
35345     } catch (...) {
35346       {
35347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35348       };
35349     }
35350   }
35351
35352 }
35353
35354
35355 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
35356   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35357   float arg2 ;
35358   float arg3 ;
35359   float arg4 ;
35360
35361   arg1 = (Dali::Actor *)jarg1;
35362   arg2 = (float)jarg2;
35363   arg3 = (float)jarg3;
35364   arg4 = (float)jarg4;
35365   {
35366     try {
35367       (arg1)->SetScale(arg2,arg3,arg4);
35368     } catch (std::out_of_range& e) {
35369       {
35370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35371       };
35372     } catch (std::exception& e) {
35373       {
35374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35375       };
35376     } catch (Dali::DaliException e) {
35377       {
35378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35379       };
35380     } catch (...) {
35381       {
35382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35383       };
35384     }
35385   }
35386
35387 }
35388
35389
35390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_2(void * jarg1, void * jarg2) {
35391   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35392   Dali::Vector3 *arg2 = 0 ;
35393
35394   arg1 = (Dali::Actor *)jarg1;
35395   arg2 = (Dali::Vector3 *)jarg2;
35396   if (!arg2) {
35397     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35398     return ;
35399   }
35400   {
35401     try {
35402       (arg1)->SetScale((Dali::Vector3 const &)*arg2);
35403     } catch (std::out_of_range& e) {
35404       {
35405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35406       };
35407     } catch (std::exception& e) {
35408       {
35409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35410       };
35411     } catch (Dali::DaliException e) {
35412       {
35413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35414       };
35415     } catch (...) {
35416       {
35417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35418       };
35419     }
35420   }
35421
35422 }
35423
35424
35425 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_ScaleBy(void * jarg1, void * jarg2) {
35426   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35427   Dali::Vector3 *arg2 = 0 ;
35428
35429   arg1 = (Dali::Actor *)jarg1;
35430   arg2 = (Dali::Vector3 *)jarg2;
35431   if (!arg2) {
35432     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35433     return ;
35434   }
35435   {
35436     try {
35437       (arg1)->ScaleBy((Dali::Vector3 const &)*arg2);
35438     } catch (std::out_of_range& e) {
35439       {
35440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35441       };
35442     } catch (std::exception& e) {
35443       {
35444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35445       };
35446     } catch (Dali::DaliException e) {
35447       {
35448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35449       };
35450     } catch (...) {
35451       {
35452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35453       };
35454     }
35455   }
35456
35457 }
35458
35459
35460 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentScale(void * jarg1) {
35461   void * jresult ;
35462   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35463   Dali::Vector3 result;
35464
35465   arg1 = (Dali::Actor *)jarg1;
35466   {
35467     try {
35468       result = ((Dali::Actor const *)arg1)->GetCurrentScale();
35469     } catch (std::out_of_range& e) {
35470       {
35471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35472       };
35473     } catch (std::exception& e) {
35474       {
35475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35476       };
35477     } catch (Dali::DaliException e) {
35478       {
35479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35480       };
35481     } catch (...) {
35482       {
35483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35484       };
35485     }
35486   }
35487
35488   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
35489   return jresult;
35490 }
35491
35492
35493 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldScale(void * jarg1) {
35494   void * jresult ;
35495   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35496   Dali::Vector3 result;
35497
35498   arg1 = (Dali::Actor *)jarg1;
35499   {
35500     try {
35501       result = ((Dali::Actor const *)arg1)->GetCurrentWorldScale();
35502     } catch (std::out_of_range& e) {
35503       {
35504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35505       };
35506     } catch (std::exception& e) {
35507       {
35508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35509       };
35510     } catch (Dali::DaliException e) {
35511       {
35512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35513       };
35514     } catch (...) {
35515       {
35516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35517       };
35518     }
35519   }
35520
35521   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
35522   return jresult;
35523 }
35524
35525
35526 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritScale(void * jarg1, unsigned int jarg2) {
35527   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35528   bool arg2 ;
35529
35530   arg1 = (Dali::Actor *)jarg1;
35531   arg2 = jarg2 ? true : false;
35532   {
35533     try {
35534       (arg1)->SetInheritScale(arg2);
35535     } catch (std::out_of_range& e) {
35536       {
35537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35538       };
35539     } catch (std::exception& e) {
35540       {
35541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35542       };
35543     } catch (Dali::DaliException e) {
35544       {
35545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35546       };
35547     } catch (...) {
35548       {
35549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35550       };
35551     }
35552   }
35553
35554 }
35555
35556
35557 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsScaleInherited(void * jarg1) {
35558   unsigned int jresult ;
35559   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35560   bool result;
35561
35562   arg1 = (Dali::Actor *)jarg1;
35563   {
35564     try {
35565       result = (bool)((Dali::Actor const *)arg1)->IsScaleInherited();
35566     } catch (std::out_of_range& e) {
35567       {
35568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35569       };
35570     } catch (std::exception& e) {
35571       {
35572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35573       };
35574     } catch (Dali::DaliException e) {
35575       {
35576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35577       };
35578     } catch (...) {
35579       {
35580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35581       };
35582     }
35583   }
35584
35585   jresult = result;
35586   return jresult;
35587 }
35588
35589
35590 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldMatrix(void * jarg1) {
35591   void * jresult ;
35592   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35593   Dali::Matrix result;
35594
35595   arg1 = (Dali::Actor *)jarg1;
35596   {
35597     try {
35598       result = ((Dali::Actor const *)arg1)->GetCurrentWorldMatrix();
35599     } catch (std::out_of_range& e) {
35600       {
35601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35602       };
35603     } catch (std::exception& e) {
35604       {
35605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35606       };
35607     } catch (Dali::DaliException e) {
35608       {
35609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35610       };
35611     } catch (...) {
35612       {
35613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35614       };
35615     }
35616   }
35617
35618   jresult = new Dali::Matrix((const Dali::Matrix &)result);
35619   return jresult;
35620 }
35621
35622
35623 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetVisible(void * jarg1, unsigned int jarg2) {
35624   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35625   bool arg2 ;
35626
35627   arg1 = (Dali::Actor *)jarg1;
35628   arg2 = jarg2 ? true : false;
35629   {
35630     try {
35631       (arg1)->SetVisible(arg2);
35632     } catch (std::out_of_range& e) {
35633       {
35634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35635       };
35636     } catch (std::exception& e) {
35637       {
35638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35639       };
35640     } catch (Dali::DaliException e) {
35641       {
35642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35643       };
35644     } catch (...) {
35645       {
35646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35647       };
35648     }
35649   }
35650
35651 }
35652
35653
35654 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsVisible(void * jarg1) {
35655   unsigned int jresult ;
35656   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35657   bool result;
35658
35659   arg1 = (Dali::Actor *)jarg1;
35660   {
35661     try {
35662       result = (bool)((Dali::Actor const *)arg1)->IsVisible();
35663     } catch (std::out_of_range& e) {
35664       {
35665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35666       };
35667     } catch (std::exception& e) {
35668       {
35669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35670       };
35671     } catch (Dali::DaliException e) {
35672       {
35673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35674       };
35675     } catch (...) {
35676       {
35677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35678       };
35679     }
35680   }
35681
35682   jresult = result;
35683   return jresult;
35684 }
35685
35686
35687 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOpacity(void * jarg1, float jarg2) {
35688   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35689   float arg2 ;
35690
35691   arg1 = (Dali::Actor *)jarg1;
35692   arg2 = (float)jarg2;
35693   {
35694     try {
35695       (arg1)->SetOpacity(arg2);
35696     } catch (std::out_of_range& e) {
35697       {
35698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35699       };
35700     } catch (std::exception& e) {
35701       {
35702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35703       };
35704     } catch (Dali::DaliException e) {
35705       {
35706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35707       };
35708     } catch (...) {
35709       {
35710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35711       };
35712     }
35713   }
35714
35715 }
35716
35717
35718 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOpacity(void * jarg1) {
35719   float jresult ;
35720   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35721   float result;
35722
35723   arg1 = (Dali::Actor *)jarg1;
35724   {
35725     try {
35726       result = (float)((Dali::Actor const *)arg1)->GetCurrentOpacity();
35727     } catch (std::out_of_range& e) {
35728       {
35729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35730       };
35731     } catch (std::exception& e) {
35732       {
35733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35734       };
35735     } catch (Dali::DaliException e) {
35736       {
35737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35738       };
35739     } catch (...) {
35740       {
35741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35742       };
35743     }
35744   }
35745
35746   jresult = result;
35747   return jresult;
35748 }
35749
35750
35751 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColor(void * jarg1, void * jarg2) {
35752   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35753   Dali::Vector4 *arg2 = 0 ;
35754
35755   arg1 = (Dali::Actor *)jarg1;
35756   arg2 = (Dali::Vector4 *)jarg2;
35757   if (!arg2) {
35758     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
35759     return ;
35760   }
35761   {
35762     try {
35763       (arg1)->SetColor((Dali::Vector4 const &)*arg2);
35764     } catch (std::out_of_range& e) {
35765       {
35766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35767       };
35768     } catch (std::exception& e) {
35769       {
35770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35771       };
35772     } catch (Dali::DaliException e) {
35773       {
35774         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35775       };
35776     } catch (...) {
35777       {
35778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35779       };
35780     }
35781   }
35782
35783 }
35784
35785
35786 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentColor(void * jarg1) {
35787   void * jresult ;
35788   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35789   Dali::Vector4 result;
35790
35791   arg1 = (Dali::Actor *)jarg1;
35792   {
35793     try {
35794       result = ((Dali::Actor const *)arg1)->GetCurrentColor();
35795     } catch (std::out_of_range& e) {
35796       {
35797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35798       };
35799     } catch (std::exception& e) {
35800       {
35801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35802       };
35803     } catch (Dali::DaliException e) {
35804       {
35805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35806       };
35807     } catch (...) {
35808       {
35809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35810       };
35811     }
35812   }
35813
35814   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
35815   return jresult;
35816 }
35817
35818
35819 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColorMode(void * jarg1, int jarg2) {
35820   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35821   Dali::ColorMode arg2 ;
35822
35823   arg1 = (Dali::Actor *)jarg1;
35824   arg2 = (Dali::ColorMode)jarg2;
35825   {
35826     try {
35827       (arg1)->SetColorMode(arg2);
35828     } catch (std::out_of_range& e) {
35829       {
35830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35831       };
35832     } catch (std::exception& e) {
35833       {
35834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35835       };
35836     } catch (Dali::DaliException e) {
35837       {
35838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35839       };
35840     } catch (...) {
35841       {
35842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35843       };
35844     }
35845   }
35846
35847 }
35848
35849
35850 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetColorMode(void * jarg1) {
35851   int jresult ;
35852   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35853   Dali::ColorMode result;
35854
35855   arg1 = (Dali::Actor *)jarg1;
35856   {
35857     try {
35858       result = (Dali::ColorMode)((Dali::Actor const *)arg1)->GetColorMode();
35859     } catch (std::out_of_range& e) {
35860       {
35861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35862       };
35863     } catch (std::exception& e) {
35864       {
35865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35866       };
35867     } catch (Dali::DaliException e) {
35868       {
35869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35870       };
35871     } catch (...) {
35872       {
35873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35874       };
35875     }
35876   }
35877
35878   jresult = (int)result;
35879   return jresult;
35880 }
35881
35882
35883 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldColor(void * jarg1) {
35884   void * jresult ;
35885   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35886   Dali::Vector4 result;
35887
35888   arg1 = (Dali::Actor *)jarg1;
35889   {
35890     try {
35891       result = ((Dali::Actor const *)arg1)->GetCurrentWorldColor();
35892     } catch (std::out_of_range& e) {
35893       {
35894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35895       };
35896     } catch (std::exception& e) {
35897       {
35898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35899       };
35900     } catch (Dali::DaliException e) {
35901       {
35902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35903       };
35904     } catch (...) {
35905       {
35906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35907       };
35908     }
35909   }
35910
35911   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
35912   return jresult;
35913 }
35914
35915
35916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetDrawMode(void * jarg1, int jarg2) {
35917   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35918   Dali::DrawMode::Type arg2 ;
35919
35920   arg1 = (Dali::Actor *)jarg1;
35921   arg2 = (Dali::DrawMode::Type)jarg2;
35922   {
35923     try {
35924       (arg1)->SetDrawMode(arg2);
35925     } catch (std::out_of_range& e) {
35926       {
35927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35928       };
35929     } catch (std::exception& e) {
35930       {
35931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35932       };
35933     } catch (Dali::DaliException e) {
35934       {
35935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35936       };
35937     } catch (...) {
35938       {
35939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35940       };
35941     }
35942   }
35943
35944 }
35945
35946
35947 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetDrawMode(void * jarg1) {
35948   int jresult ;
35949   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35950   Dali::DrawMode::Type result;
35951
35952   arg1 = (Dali::Actor *)jarg1;
35953   {
35954     try {
35955       result = (Dali::DrawMode::Type)((Dali::Actor const *)arg1)->GetDrawMode();
35956     } catch (std::out_of_range& e) {
35957       {
35958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35959       };
35960     } catch (std::exception& e) {
35961       {
35962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35963       };
35964     } catch (Dali::DaliException e) {
35965       {
35966         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35967       };
35968     } catch (...) {
35969       {
35970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35971       };
35972     }
35973   }
35974
35975   jresult = (int)result;
35976   return jresult;
35977 }
35978
35979
35980 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSensitive(void * jarg1, unsigned int jarg2) {
35981   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35982   bool arg2 ;
35983
35984   arg1 = (Dali::Actor *)jarg1;
35985   arg2 = jarg2 ? true : false;
35986   {
35987     try {
35988       (arg1)->SetSensitive(arg2);
35989     } catch (std::out_of_range& e) {
35990       {
35991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35992       };
35993     } catch (std::exception& e) {
35994       {
35995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35996       };
35997     } catch (Dali::DaliException e) {
35998       {
35999         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36000       };
36001     } catch (...) {
36002       {
36003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36004       };
36005     }
36006   }
36007
36008 }
36009
36010
36011 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsSensitive(void * jarg1) {
36012   unsigned int jresult ;
36013   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36014   bool result;
36015
36016   arg1 = (Dali::Actor *)jarg1;
36017   {
36018     try {
36019       result = (bool)((Dali::Actor const *)arg1)->IsSensitive();
36020     } catch (std::out_of_range& e) {
36021       {
36022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36023       };
36024     } catch (std::exception& e) {
36025       {
36026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36027       };
36028     } catch (Dali::DaliException e) {
36029       {
36030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36031       };
36032     } catch (...) {
36033       {
36034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36035       };
36036     }
36037   }
36038
36039   jresult = result;
36040   return jresult;
36041 }
36042
36043
36044 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_ScreenToLocal(void * jarg1, float * jarg2, float * jarg3, float jarg4, float jarg5) {
36045   unsigned int jresult ;
36046   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36047   float *arg2 = 0 ;
36048   float *arg3 = 0 ;
36049   float arg4 ;
36050   float arg5 ;
36051   bool result;
36052
36053   arg1 = (Dali::Actor *)jarg1;
36054   arg2 = (float *)jarg2;
36055   arg3 = (float *)jarg3;
36056   arg4 = (float)jarg4;
36057   arg5 = (float)jarg5;
36058   {
36059     try {
36060       result = (bool)((Dali::Actor const *)arg1)->ScreenToLocal(*arg2,*arg3,arg4,arg5);
36061     } catch (std::out_of_range& e) {
36062       {
36063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36064       };
36065     } catch (std::exception& e) {
36066       {
36067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36068       };
36069     } catch (Dali::DaliException e) {
36070       {
36071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36072       };
36073     } catch (...) {
36074       {
36075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36076       };
36077     }
36078   }
36079
36080   jresult = result;
36081   return jresult;
36082 }
36083
36084
36085 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetLeaveRequired(void * jarg1, unsigned int jarg2) {
36086   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36087   bool arg2 ;
36088
36089   arg1 = (Dali::Actor *)jarg1;
36090   arg2 = jarg2 ? true : false;
36091   {
36092     try {
36093       (arg1)->SetLeaveRequired(arg2);
36094     } catch (std::out_of_range& e) {
36095       {
36096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36097       };
36098     } catch (std::exception& e) {
36099       {
36100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36101       };
36102     } catch (Dali::DaliException e) {
36103       {
36104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36105       };
36106     } catch (...) {
36107       {
36108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36109       };
36110     }
36111   }
36112
36113 }
36114
36115
36116 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetLeaveRequired(void * jarg1) {
36117   unsigned int jresult ;
36118   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36119   bool result;
36120
36121   arg1 = (Dali::Actor *)jarg1;
36122   {
36123     try {
36124       result = (bool)((Dali::Actor const *)arg1)->GetLeaveRequired();
36125     } catch (std::out_of_range& e) {
36126       {
36127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36128       };
36129     } catch (std::exception& e) {
36130       {
36131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36132       };
36133     } catch (Dali::DaliException e) {
36134       {
36135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36136       };
36137     } catch (...) {
36138       {
36139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36140       };
36141     }
36142   }
36143
36144   jresult = result;
36145   return jresult;
36146 }
36147
36148
36149 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetKeyboardFocusable(void * jarg1, unsigned int jarg2) {
36150   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36151   bool arg2 ;
36152
36153   arg1 = (Dali::Actor *)jarg1;
36154   arg2 = jarg2 ? true : false;
36155   {
36156     try {
36157       (arg1)->SetKeyboardFocusable(arg2);
36158     } catch (std::out_of_range& e) {
36159       {
36160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36161       };
36162     } catch (std::exception& e) {
36163       {
36164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36165       };
36166     } catch (Dali::DaliException e) {
36167       {
36168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36169       };
36170     } catch (...) {
36171       {
36172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36173       };
36174     }
36175   }
36176
36177 }
36178
36179
36180 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsKeyboardFocusable(void * jarg1) {
36181   unsigned int jresult ;
36182   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36183   bool result;
36184
36185   arg1 = (Dali::Actor *)jarg1;
36186   {
36187     try {
36188       result = (bool)((Dali::Actor const *)arg1)->IsKeyboardFocusable();
36189     } catch (std::out_of_range& e) {
36190       {
36191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36192       };
36193     } catch (std::exception& e) {
36194       {
36195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36196       };
36197     } catch (Dali::DaliException e) {
36198       {
36199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36200       };
36201     } catch (...) {
36202       {
36203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36204       };
36205     }
36206   }
36207
36208   jresult = result;
36209   return jresult;
36210 }
36211
36212
36213 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetResizePolicy(void * jarg1, int jarg2, int jarg3) {
36214   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36215   Dali::ResizePolicy::Type arg2 ;
36216   Dali::Dimension::Type arg3 ;
36217
36218   arg1 = (Dali::Actor *)jarg1;
36219   arg2 = (Dali::ResizePolicy::Type)jarg2;
36220   arg3 = (Dali::Dimension::Type)jarg3;
36221   {
36222     try {
36223       (arg1)->SetResizePolicy(arg2,arg3);
36224     } catch (std::out_of_range& e) {
36225       {
36226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36227       };
36228     } catch (std::exception& e) {
36229       {
36230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36231       };
36232     } catch (Dali::DaliException e) {
36233       {
36234         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36235       };
36236     } catch (...) {
36237       {
36238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36239       };
36240     }
36241   }
36242
36243 }
36244
36245
36246 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetResizePolicy(void * jarg1, int jarg2) {
36247   int jresult ;
36248   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36249   Dali::Dimension::Type arg2 ;
36250   Dali::ResizePolicy::Type result;
36251
36252   arg1 = (Dali::Actor *)jarg1;
36253   arg2 = (Dali::Dimension::Type)jarg2;
36254   {
36255     try {
36256       result = (Dali::ResizePolicy::Type)((Dali::Actor const *)arg1)->GetResizePolicy(arg2);
36257     } catch (std::out_of_range& e) {
36258       {
36259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36260       };
36261     } catch (std::exception& e) {
36262       {
36263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36264       };
36265     } catch (Dali::DaliException e) {
36266       {
36267         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36268       };
36269     } catch (...) {
36270       {
36271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36272       };
36273     }
36274   }
36275
36276   jresult = (int)result;
36277   return jresult;
36278 }
36279
36280
36281 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeScalePolicy(void * jarg1, int jarg2) {
36282   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36283   Dali::SizeScalePolicy::Type arg2 ;
36284
36285   arg1 = (Dali::Actor *)jarg1;
36286   arg2 = (Dali::SizeScalePolicy::Type)jarg2;
36287   {
36288     try {
36289       (arg1)->SetSizeScalePolicy(arg2);
36290     } catch (std::out_of_range& e) {
36291       {
36292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36293       };
36294     } catch (std::exception& e) {
36295       {
36296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36297       };
36298     } catch (Dali::DaliException e) {
36299       {
36300         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36301       };
36302     } catch (...) {
36303       {
36304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36305       };
36306     }
36307   }
36308
36309 }
36310
36311
36312 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetSizeScalePolicy(void * jarg1) {
36313   int jresult ;
36314   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36315   Dali::SizeScalePolicy::Type result;
36316
36317   arg1 = (Dali::Actor *)jarg1;
36318   {
36319     try {
36320       result = (Dali::SizeScalePolicy::Type)((Dali::Actor const *)arg1)->GetSizeScalePolicy();
36321     } catch (std::out_of_range& e) {
36322       {
36323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36324       };
36325     } catch (std::exception& e) {
36326       {
36327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36328       };
36329     } catch (Dali::DaliException e) {
36330       {
36331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36332       };
36333     } catch (...) {
36334       {
36335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36336       };
36337     }
36338   }
36339
36340   jresult = (int)result;
36341   return jresult;
36342 }
36343
36344
36345 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeModeFactor(void * jarg1, void * jarg2) {
36346   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36347   Dali::Vector3 *arg2 = 0 ;
36348
36349   arg1 = (Dali::Actor *)jarg1;
36350   arg2 = (Dali::Vector3 *)jarg2;
36351   if (!arg2) {
36352     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
36353     return ;
36354   }
36355   {
36356     try {
36357       (arg1)->SetSizeModeFactor((Dali::Vector3 const &)*arg2);
36358     } catch (std::out_of_range& e) {
36359       {
36360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36361       };
36362     } catch (std::exception& e) {
36363       {
36364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36365       };
36366     } catch (Dali::DaliException e) {
36367       {
36368         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36369       };
36370     } catch (...) {
36371       {
36372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36373       };
36374     }
36375   }
36376
36377 }
36378
36379
36380 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetSizeModeFactor(void * jarg1) {
36381   void * jresult ;
36382   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36383   Dali::Vector3 result;
36384
36385   arg1 = (Dali::Actor *)jarg1;
36386   {
36387     try {
36388       result = ((Dali::Actor const *)arg1)->GetSizeModeFactor();
36389     } catch (std::out_of_range& e) {
36390       {
36391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36392       };
36393     } catch (std::exception& e) {
36394       {
36395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36396       };
36397     } catch (Dali::DaliException e) {
36398       {
36399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36400       };
36401     } catch (...) {
36402       {
36403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36404       };
36405     }
36406   }
36407
36408   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
36409   return jresult;
36410 }
36411
36412
36413 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetHeightForWidth(void * jarg1, float jarg2) {
36414   float jresult ;
36415   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36416   float arg2 ;
36417   float result;
36418
36419   arg1 = (Dali::Actor *)jarg1;
36420   arg2 = (float)jarg2;
36421   {
36422     try {
36423       result = (float)(arg1)->GetHeightForWidth(arg2);
36424     } catch (std::out_of_range& e) {
36425       {
36426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36427       };
36428     } catch (std::exception& e) {
36429       {
36430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36431       };
36432     } catch (Dali::DaliException e) {
36433       {
36434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36435       };
36436     } catch (...) {
36437       {
36438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36439       };
36440     }
36441   }
36442
36443   jresult = result;
36444   return jresult;
36445 }
36446
36447
36448 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetWidthForHeight(void * jarg1, float jarg2) {
36449   float jresult ;
36450   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36451   float arg2 ;
36452   float result;
36453
36454   arg1 = (Dali::Actor *)jarg1;
36455   arg2 = (float)jarg2;
36456   {
36457     try {
36458       result = (float)(arg1)->GetWidthForHeight(arg2);
36459     } catch (std::out_of_range& e) {
36460       {
36461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36462       };
36463     } catch (std::exception& e) {
36464       {
36465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36466       };
36467     } catch (Dali::DaliException e) {
36468       {
36469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36470       };
36471     } catch (...) {
36472       {
36473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36474       };
36475     }
36476   }
36477
36478   jresult = result;
36479   return jresult;
36480 }
36481
36482
36483 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetRelayoutSize(void * jarg1, int jarg2) {
36484   float jresult ;
36485   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36486   Dali::Dimension::Type arg2 ;
36487   float result;
36488
36489   arg1 = (Dali::Actor *)jarg1;
36490   arg2 = (Dali::Dimension::Type)jarg2;
36491   {
36492     try {
36493       result = (float)((Dali::Actor const *)arg1)->GetRelayoutSize(arg2);
36494     } catch (std::out_of_range& e) {
36495       {
36496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36497       };
36498     } catch (std::exception& e) {
36499       {
36500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36501       };
36502     } catch (Dali::DaliException e) {
36503       {
36504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36505       };
36506     } catch (...) {
36507       {
36508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36509       };
36510     }
36511   }
36512
36513   jresult = result;
36514   return jresult;
36515 }
36516
36517
36518 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPadding(void * jarg1, void * jarg2) {
36519   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36520   Dali::Padding *arg2 = 0 ;
36521
36522   arg1 = (Dali::Actor *)jarg1;
36523   arg2 = (Dali::Padding *)jarg2;
36524   if (!arg2) {
36525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding const & type is null", 0);
36526     return ;
36527   }
36528   {
36529     try {
36530       (arg1)->SetPadding((Dali::Padding const &)*arg2);
36531     } catch (std::out_of_range& e) {
36532       {
36533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36534       };
36535     } catch (std::exception& e) {
36536       {
36537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36538       };
36539     } catch (Dali::DaliException e) {
36540       {
36541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36542       };
36543     } catch (...) {
36544       {
36545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36546       };
36547     }
36548   }
36549
36550 }
36551
36552
36553 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_GetPadding(void * jarg1, void * jarg2) {
36554   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36555   Dali::Padding *arg2 = 0 ;
36556
36557   arg1 = (Dali::Actor *)jarg1;
36558   arg2 = (Dali::Padding *)jarg2;
36559   if (!arg2) {
36560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding & type is null", 0);
36561     return ;
36562   }
36563   {
36564     try {
36565       ((Dali::Actor const *)arg1)->GetPadding(*arg2);
36566     } catch (std::out_of_range& e) {
36567       {
36568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36569       };
36570     } catch (std::exception& e) {
36571       {
36572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36573       };
36574     } catch (Dali::DaliException e) {
36575       {
36576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36577       };
36578     } catch (...) {
36579       {
36580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36581       };
36582     }
36583   }
36584
36585 }
36586
36587
36588 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMinimumSize(void * jarg1, void * jarg2) {
36589   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36590   Dali::Vector2 *arg2 = 0 ;
36591
36592   arg1 = (Dali::Actor *)jarg1;
36593   arg2 = (Dali::Vector2 *)jarg2;
36594   if (!arg2) {
36595     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
36596     return ;
36597   }
36598   {
36599     try {
36600       (arg1)->SetMinimumSize((Dali::Vector2 const &)*arg2);
36601     } catch (std::out_of_range& e) {
36602       {
36603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36604       };
36605     } catch (std::exception& e) {
36606       {
36607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36608       };
36609     } catch (Dali::DaliException e) {
36610       {
36611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36612       };
36613     } catch (...) {
36614       {
36615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36616       };
36617     }
36618   }
36619
36620 }
36621
36622
36623 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMinimumSize(void * jarg1) {
36624   void * jresult ;
36625   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36626   Dali::Vector2 result;
36627
36628   arg1 = (Dali::Actor *)jarg1;
36629   {
36630     try {
36631       result = (arg1)->GetMinimumSize();
36632     } catch (std::out_of_range& e) {
36633       {
36634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36635       };
36636     } catch (std::exception& e) {
36637       {
36638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36639       };
36640     } catch (Dali::DaliException e) {
36641       {
36642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36643       };
36644     } catch (...) {
36645       {
36646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36647       };
36648     }
36649   }
36650
36651   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
36652   return jresult;
36653 }
36654
36655
36656 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMaximumSize(void * jarg1, void * jarg2) {
36657   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36658   Dali::Vector2 *arg2 = 0 ;
36659
36660   arg1 = (Dali::Actor *)jarg1;
36661   arg2 = (Dali::Vector2 *)jarg2;
36662   if (!arg2) {
36663     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
36664     return ;
36665   }
36666   {
36667     try {
36668       (arg1)->SetMaximumSize((Dali::Vector2 const &)*arg2);
36669     } catch (std::out_of_range& e) {
36670       {
36671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36672       };
36673     } catch (std::exception& e) {
36674       {
36675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36676       };
36677     } catch (Dali::DaliException e) {
36678       {
36679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36680       };
36681     } catch (...) {
36682       {
36683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36684       };
36685     }
36686   }
36687
36688 }
36689
36690
36691 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMaximumSize(void * jarg1) {
36692   void * jresult ;
36693   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36694   Dali::Vector2 result;
36695
36696   arg1 = (Dali::Actor *)jarg1;
36697   {
36698     try {
36699       result = (arg1)->GetMaximumSize();
36700     } catch (std::out_of_range& e) {
36701       {
36702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36703       };
36704     } catch (std::exception& e) {
36705       {
36706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36707       };
36708     } catch (Dali::DaliException e) {
36709       {
36710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36711       };
36712     } catch (...) {
36713       {
36714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36715       };
36716     }
36717   }
36718
36719   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
36720   return jresult;
36721 }
36722
36723
36724 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetHierarchyDepth(void * jarg1) {
36725   int jresult ;
36726   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36727   int result;
36728
36729   arg1 = (Dali::Actor *)jarg1;
36730   {
36731     try {
36732       result = (int)(arg1)->GetHierarchyDepth();
36733     } catch (std::out_of_range& e) {
36734       {
36735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36736       };
36737     } catch (std::exception& e) {
36738       {
36739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36740       };
36741     } catch (Dali::DaliException e) {
36742       {
36743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36744       };
36745     } catch (...) {
36746       {
36747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36748       };
36749     }
36750   }
36751
36752   jresult = result;
36753   return jresult;
36754 }
36755
36756
36757 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_AddRenderer(void * jarg1, void * jarg2) {
36758   unsigned int jresult ;
36759   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36760   Dali::Renderer *arg2 = 0 ;
36761   unsigned int result;
36762
36763   arg1 = (Dali::Actor *)jarg1;
36764   arg2 = (Dali::Renderer *)jarg2;
36765   if (!arg2) {
36766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
36767     return 0;
36768   }
36769   {
36770     try {
36771       result = (unsigned int)(arg1)->AddRenderer(*arg2);
36772     } catch (std::out_of_range& e) {
36773       {
36774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36775       };
36776     } catch (std::exception& e) {
36777       {
36778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36779       };
36780     } catch (Dali::DaliException e) {
36781       {
36782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36783       };
36784     } catch (...) {
36785       {
36786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36787       };
36788     }
36789   }
36790
36791   jresult = result;
36792   return jresult;
36793 }
36794
36795
36796 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetRendererCount(void * jarg1) {
36797   unsigned int jresult ;
36798   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36799   unsigned int result;
36800
36801   arg1 = (Dali::Actor *)jarg1;
36802   {
36803     try {
36804       result = (unsigned int)((Dali::Actor const *)arg1)->GetRendererCount();
36805     } catch (std::out_of_range& e) {
36806       {
36807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36808       };
36809     } catch (std::exception& e) {
36810       {
36811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36812       };
36813     } catch (Dali::DaliException e) {
36814       {
36815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36816       };
36817     } catch (...) {
36818       {
36819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36820       };
36821     }
36822   }
36823
36824   jresult = result;
36825   return jresult;
36826 }
36827
36828
36829 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetRendererAt(void * jarg1, unsigned int jarg2) {
36830   void * jresult ;
36831   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36832   unsigned int arg2 ;
36833   Dali::Renderer result;
36834
36835   arg1 = (Dali::Actor *)jarg1;
36836   arg2 = (unsigned int)jarg2;
36837   {
36838     try {
36839       result = (arg1)->GetRendererAt(arg2);
36840     } catch (std::out_of_range& e) {
36841       {
36842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36843       };
36844     } catch (std::exception& e) {
36845       {
36846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36847       };
36848     } catch (Dali::DaliException e) {
36849       {
36850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36851       };
36852     } catch (...) {
36853       {
36854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36855       };
36856     }
36857   }
36858
36859   jresult = new Dali::Renderer((const Dali::Renderer &)result);
36860   return jresult;
36861 }
36862
36863
36864 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_0(void * jarg1, void * jarg2) {
36865   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36866   Dali::Renderer *arg2 = 0 ;
36867
36868   arg1 = (Dali::Actor *)jarg1;
36869   arg2 = (Dali::Renderer *)jarg2;
36870   if (!arg2) {
36871     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
36872     return ;
36873   }
36874   {
36875     try {
36876       (arg1)->RemoveRenderer(*arg2);
36877     } catch (std::out_of_range& e) {
36878       {
36879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36880       };
36881     } catch (std::exception& e) {
36882       {
36883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36884       };
36885     } catch (Dali::DaliException e) {
36886       {
36887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36888       };
36889     } catch (...) {
36890       {
36891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36892       };
36893     }
36894   }
36895
36896 }
36897
36898
36899 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_1(void * jarg1, unsigned int jarg2) {
36900   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36901   unsigned int arg2 ;
36902
36903   arg1 = (Dali::Actor *)jarg1;
36904   arg2 = (unsigned int)jarg2;
36905   {
36906     try {
36907       (arg1)->RemoveRenderer(arg2);
36908     } catch (std::out_of_range& e) {
36909       {
36910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36911       };
36912     } catch (std::exception& e) {
36913       {
36914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36915       };
36916     } catch (Dali::DaliException e) {
36917       {
36918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36919       };
36920     } catch (...) {
36921       {
36922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36923       };
36924     }
36925   }
36926
36927 }
36928
36929
36930 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchedSignal(void * jarg1) {
36931   void * jresult ;
36932   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36933   Dali::Actor::TouchSignalType *result = 0 ;
36934
36935   arg1 = (Dali::Actor *)jarg1;
36936   {
36937     try {
36938       result = (Dali::Actor::TouchSignalType *) &(arg1)->TouchedSignal();
36939     } catch (std::out_of_range& e) {
36940       {
36941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36942       };
36943     } catch (std::exception& e) {
36944       {
36945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36946       };
36947     } catch (Dali::DaliException e) {
36948       {
36949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36950       };
36951     } catch (...) {
36952       {
36953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36954       };
36955     }
36956   }
36957
36958   jresult = (void *)result;
36959   return jresult;
36960 }
36961
36962
36963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchSignal(void * jarg1) {
36964   void * jresult ;
36965   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36966   Dali::Actor::TouchDataSignalType *result = 0 ;
36967
36968   arg1 = (Dali::Actor *)jarg1;
36969   {
36970     try {
36971       result = (Dali::Actor::TouchDataSignalType *) &(arg1)->TouchSignal();
36972     } catch (std::out_of_range& e) {
36973       {
36974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36975       };
36976     } catch (std::exception& e) {
36977       {
36978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36979       };
36980     } catch (Dali::DaliException e) {
36981       {
36982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36983       };
36984     } catch (...) {
36985       {
36986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36987       };
36988     }
36989   }
36990
36991   jresult = (void *)result;
36992   return jresult;
36993 }
36994
36995
36996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_HoveredSignal(void * jarg1) {
36997   void * jresult ;
36998   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36999   Dali::Actor::HoverSignalType *result = 0 ;
37000
37001   arg1 = (Dali::Actor *)jarg1;
37002   {
37003     try {
37004       result = (Dali::Actor::HoverSignalType *) &(arg1)->HoveredSignal();
37005     } catch (std::out_of_range& e) {
37006       {
37007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37008       };
37009     } catch (std::exception& e) {
37010       {
37011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37012       };
37013     } catch (Dali::DaliException e) {
37014       {
37015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37016       };
37017     } catch (...) {
37018       {
37019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37020       };
37021     }
37022   }
37023
37024   jresult = (void *)result;
37025   return jresult;
37026 }
37027
37028
37029 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_WheelEventSignal(void * jarg1) {
37030   void * jresult ;
37031   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37032   Dali::Actor::WheelEventSignalType *result = 0 ;
37033
37034   arg1 = (Dali::Actor *)jarg1;
37035   {
37036     try {
37037       result = (Dali::Actor::WheelEventSignalType *) &(arg1)->WheelEventSignal();
37038     } catch (std::out_of_range& e) {
37039       {
37040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37041       };
37042     } catch (std::exception& e) {
37043       {
37044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37045       };
37046     } catch (Dali::DaliException e) {
37047       {
37048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37049       };
37050     } catch (...) {
37051       {
37052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37053       };
37054     }
37055   }
37056
37057   jresult = (void *)result;
37058   return jresult;
37059 }
37060
37061
37062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnStageSignal(void * jarg1) {
37063   void * jresult ;
37064   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37065   Dali::Actor::OnStageSignalType *result = 0 ;
37066
37067   arg1 = (Dali::Actor *)jarg1;
37068   {
37069     try {
37070       result = (Dali::Actor::OnStageSignalType *) &(arg1)->OnStageSignal();
37071     } catch (std::out_of_range& e) {
37072       {
37073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37074       };
37075     } catch (std::exception& e) {
37076       {
37077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37078       };
37079     } catch (Dali::DaliException e) {
37080       {
37081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37082       };
37083     } catch (...) {
37084       {
37085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37086       };
37087     }
37088   }
37089
37090   jresult = (void *)result;
37091   return jresult;
37092 }
37093
37094
37095 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OffStageSignal(void * jarg1) {
37096   void * jresult ;
37097   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37098   Dali::Actor::OffStageSignalType *result = 0 ;
37099
37100   arg1 = (Dali::Actor *)jarg1;
37101   {
37102     try {
37103       result = (Dali::Actor::OffStageSignalType *) &(arg1)->OffStageSignal();
37104     } catch (std::out_of_range& e) {
37105       {
37106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37107       };
37108     } catch (std::exception& e) {
37109       {
37110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37111       };
37112     } catch (Dali::DaliException e) {
37113       {
37114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37115       };
37116     } catch (...) {
37117       {
37118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37119       };
37120     }
37121   }
37122
37123   jresult = (void *)result;
37124   return jresult;
37125 }
37126
37127
37128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnRelayoutSignal(void * jarg1) {
37129   void * jresult ;
37130   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37131   Dali::Actor::OnRelayoutSignalType *result = 0 ;
37132
37133   arg1 = (Dali::Actor *)jarg1;
37134   {
37135     try {
37136       result = (Dali::Actor::OnRelayoutSignalType *) &(arg1)->OnRelayoutSignal();
37137     } catch (std::out_of_range& e) {
37138       {
37139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37140       };
37141     } catch (std::exception& e) {
37142       {
37143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37144       };
37145     } catch (Dali::DaliException e) {
37146       {
37147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37148       };
37149     } catch (...) {
37150       {
37151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37152       };
37153     }
37154   }
37155
37156   jresult = (void *)result;
37157   return jresult;
37158 }
37159
37160
37161 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_UnparentAndReset(void * jarg1) {
37162   Dali::Actor *arg1 = 0 ;
37163
37164   arg1 = (Dali::Actor *)jarg1;
37165   if (!arg1) {
37166     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
37167     return ;
37168   }
37169   {
37170     try {
37171       Dali::UnparentAndReset(*arg1);
37172     } catch (std::out_of_range& e) {
37173       {
37174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37175       };
37176     } catch (std::exception& e) {
37177       {
37178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37179       };
37180     } catch (Dali::DaliException e) {
37181       {
37182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37183       };
37184     } catch (...) {
37185       {
37186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37187       };
37188     }
37189   }
37190
37191 }
37192
37193
37194 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_ENABLE_get() {
37195   int jresult ;
37196   int result;
37197
37198   result = (int)Dali::Layer::Property::CLIPPING_ENABLE;
37199   jresult = (int)result;
37200   return jresult;
37201 }
37202
37203
37204 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_BOX_get() {
37205   int jresult ;
37206   int result;
37207
37208   result = (int)Dali::Layer::Property::CLIPPING_BOX;
37209   jresult = (int)result;
37210   return jresult;
37211 }
37212
37213
37214 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_BEHAVIOR_get() {
37215   int jresult ;
37216   int result;
37217
37218   result = (int)Dali::Layer::Property::BEHAVIOR;
37219   jresult = (int)result;
37220   return jresult;
37221 }
37222
37223
37224 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer_Property() {
37225   void * jresult ;
37226   Dali::Layer::Property *result = 0 ;
37227
37228   {
37229     try {
37230       result = (Dali::Layer::Property *)new Dali::Layer::Property();
37231     } catch (std::out_of_range& e) {
37232       {
37233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37234       };
37235     } catch (std::exception& e) {
37236       {
37237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37238       };
37239     } catch (Dali::DaliException e) {
37240       {
37241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37242       };
37243     } catch (...) {
37244       {
37245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37246       };
37247     }
37248   }
37249
37250   jresult = (void *)result;
37251   return jresult;
37252 }
37253
37254
37255 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer_Property(void * jarg1) {
37256   Dali::Layer::Property *arg1 = (Dali::Layer::Property *) 0 ;
37257
37258   arg1 = (Dali::Layer::Property *)jarg1;
37259   {
37260     try {
37261       delete arg1;
37262     } catch (std::out_of_range& e) {
37263       {
37264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37265       };
37266     } catch (std::exception& e) {
37267       {
37268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37269       };
37270     } catch (Dali::DaliException e) {
37271       {
37272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37273       };
37274     } catch (...) {
37275       {
37276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37277       };
37278     }
37279   }
37280
37281 }
37282
37283
37284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_0() {
37285   void * jresult ;
37286   Dali::Layer *result = 0 ;
37287
37288   {
37289     try {
37290       result = (Dali::Layer *)new Dali::Layer();
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 = (void *)result;
37311   return jresult;
37312 }
37313
37314
37315 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_New() {
37316   void * jresult ;
37317   Dali::Layer result;
37318
37319   {
37320     try {
37321       result = Dali::Layer::New();
37322     } catch (std::out_of_range& e) {
37323       {
37324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37325       };
37326     } catch (std::exception& e) {
37327       {
37328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37329       };
37330     } catch (Dali::DaliException e) {
37331       {
37332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37333       };
37334     } catch (...) {
37335       {
37336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37337       };
37338     }
37339   }
37340
37341   jresult = new Dali::Layer((const Dali::Layer &)result);
37342   return jresult;
37343 }
37344
37345
37346 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_DownCast(void * jarg1) {
37347   void * jresult ;
37348   Dali::BaseHandle arg1 ;
37349   Dali::BaseHandle *argp1 ;
37350   Dali::Layer result;
37351
37352   argp1 = (Dali::BaseHandle *)jarg1;
37353   if (!argp1) {
37354     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
37355     return 0;
37356   }
37357   arg1 = *argp1;
37358   {
37359     try {
37360       result = Dali::Layer::DownCast(arg1);
37361     } catch (std::out_of_range& e) {
37362       {
37363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37364       };
37365     } catch (std::exception& e) {
37366       {
37367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37368       };
37369     } catch (Dali::DaliException e) {
37370       {
37371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37372       };
37373     } catch (...) {
37374       {
37375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37376       };
37377     }
37378   }
37379
37380   jresult = new Dali::Layer((const Dali::Layer &)result);
37381   return jresult;
37382 }
37383
37384
37385 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer(void * jarg1) {
37386   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37387
37388   arg1 = (Dali::Layer *)jarg1;
37389   {
37390     try {
37391       delete arg1;
37392     } catch (std::out_of_range& e) {
37393       {
37394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37395       };
37396     } catch (std::exception& e) {
37397       {
37398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37399       };
37400     } catch (Dali::DaliException e) {
37401       {
37402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37403       };
37404     } catch (...) {
37405       {
37406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37407       };
37408     }
37409   }
37410
37411 }
37412
37413
37414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_1(void * jarg1) {
37415   void * jresult ;
37416   Dali::Layer *arg1 = 0 ;
37417   Dali::Layer *result = 0 ;
37418
37419   arg1 = (Dali::Layer *)jarg1;
37420   if (!arg1) {
37421     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
37422     return 0;
37423   }
37424   {
37425     try {
37426       result = (Dali::Layer *)new Dali::Layer((Dali::Layer const &)*arg1);
37427     } catch (std::out_of_range& e) {
37428       {
37429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37430       };
37431     } catch (std::exception& e) {
37432       {
37433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37434       };
37435     } catch (Dali::DaliException e) {
37436       {
37437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37438       };
37439     } catch (...) {
37440       {
37441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37442       };
37443     }
37444   }
37445
37446   jresult = (void *)result;
37447   return jresult;
37448 }
37449
37450
37451 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_Assign(void * jarg1, void * jarg2) {
37452   void * jresult ;
37453   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37454   Dali::Layer *arg2 = 0 ;
37455   Dali::Layer *result = 0 ;
37456
37457   arg1 = (Dali::Layer *)jarg1;
37458   arg2 = (Dali::Layer *)jarg2;
37459   if (!arg2) {
37460     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
37461     return 0;
37462   }
37463   {
37464     try {
37465       result = (Dali::Layer *) &(arg1)->operator =((Dali::Layer const &)*arg2);
37466     } catch (std::out_of_range& e) {
37467       {
37468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37469       };
37470     } catch (std::exception& e) {
37471       {
37472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37473       };
37474     } catch (Dali::DaliException e) {
37475       {
37476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37477       };
37478     } catch (...) {
37479       {
37480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37481       };
37482     }
37483   }
37484
37485   jresult = (void *)result;
37486   return jresult;
37487 }
37488
37489
37490 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_GetDepth(void * jarg1) {
37491   unsigned int jresult ;
37492   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37493   unsigned int result;
37494
37495   arg1 = (Dali::Layer *)jarg1;
37496   {
37497     try {
37498       result = (unsigned int)((Dali::Layer const *)arg1)->GetDepth();
37499     } catch (std::out_of_range& e) {
37500       {
37501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37502       };
37503     } catch (std::exception& e) {
37504       {
37505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37506       };
37507     } catch (Dali::DaliException e) {
37508       {
37509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37510       };
37511     } catch (...) {
37512       {
37513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37514       };
37515     }
37516   }
37517
37518   jresult = result;
37519   return jresult;
37520 }
37521
37522
37523 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Raise(void * jarg1) {
37524   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37525
37526   arg1 = (Dali::Layer *)jarg1;
37527   {
37528     try {
37529       (arg1)->Raise();
37530     } catch (std::out_of_range& e) {
37531       {
37532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37533       };
37534     } catch (std::exception& e) {
37535       {
37536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37537       };
37538     } catch (Dali::DaliException e) {
37539       {
37540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37541       };
37542     } catch (...) {
37543       {
37544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37545       };
37546     }
37547   }
37548
37549 }
37550
37551
37552 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Lower(void * jarg1) {
37553   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37554
37555   arg1 = (Dali::Layer *)jarg1;
37556   {
37557     try {
37558       (arg1)->Lower();
37559     } catch (std::out_of_range& e) {
37560       {
37561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37562       };
37563     } catch (std::exception& e) {
37564       {
37565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37566       };
37567     } catch (Dali::DaliException e) {
37568       {
37569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37570       };
37571     } catch (...) {
37572       {
37573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37574       };
37575     }
37576   }
37577
37578 }
37579
37580
37581 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseAbove(void * jarg1, void * jarg2) {
37582   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37583   Dali::Layer arg2 ;
37584   Dali::Layer *argp2 ;
37585
37586   arg1 = (Dali::Layer *)jarg1;
37587   argp2 = (Dali::Layer *)jarg2;
37588   if (!argp2) {
37589     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37590     return ;
37591   }
37592   arg2 = *argp2;
37593   {
37594     try {
37595       (arg1)->RaiseAbove(arg2);
37596     } catch (std::out_of_range& e) {
37597       {
37598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37599       };
37600     } catch (std::exception& e) {
37601       {
37602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37603       };
37604     } catch (Dali::DaliException e) {
37605       {
37606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37607       };
37608     } catch (...) {
37609       {
37610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37611       };
37612     }
37613   }
37614
37615 }
37616
37617
37618 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerBelow(void * jarg1, void * jarg2) {
37619   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37620   Dali::Layer arg2 ;
37621   Dali::Layer *argp2 ;
37622
37623   arg1 = (Dali::Layer *)jarg1;
37624   argp2 = (Dali::Layer *)jarg2;
37625   if (!argp2) {
37626     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37627     return ;
37628   }
37629   arg2 = *argp2;
37630   {
37631     try {
37632       (arg1)->LowerBelow(arg2);
37633     } catch (std::out_of_range& e) {
37634       {
37635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37636       };
37637     } catch (std::exception& e) {
37638       {
37639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37640       };
37641     } catch (Dali::DaliException e) {
37642       {
37643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37644       };
37645     } catch (...) {
37646       {
37647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37648       };
37649     }
37650   }
37651
37652 }
37653
37654
37655 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseToTop(void * jarg1) {
37656   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37657
37658   arg1 = (Dali::Layer *)jarg1;
37659   {
37660     try {
37661       (arg1)->RaiseToTop();
37662     } catch (std::out_of_range& e) {
37663       {
37664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37665       };
37666     } catch (std::exception& e) {
37667       {
37668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37669       };
37670     } catch (Dali::DaliException e) {
37671       {
37672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37673       };
37674     } catch (...) {
37675       {
37676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37677       };
37678     }
37679   }
37680
37681 }
37682
37683
37684 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerToBottom(void * jarg1) {
37685   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37686
37687   arg1 = (Dali::Layer *)jarg1;
37688   {
37689     try {
37690       (arg1)->LowerToBottom();
37691     } catch (std::out_of_range& e) {
37692       {
37693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37694       };
37695     } catch (std::exception& e) {
37696       {
37697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37698       };
37699     } catch (Dali::DaliException e) {
37700       {
37701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37702       };
37703     } catch (...) {
37704       {
37705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37706       };
37707     }
37708   }
37709
37710 }
37711
37712
37713 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveAbove(void * jarg1, void * jarg2) {
37714   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37715   Dali::Layer arg2 ;
37716   Dali::Layer *argp2 ;
37717
37718   arg1 = (Dali::Layer *)jarg1;
37719   argp2 = (Dali::Layer *)jarg2;
37720   if (!argp2) {
37721     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37722     return ;
37723   }
37724   arg2 = *argp2;
37725   {
37726     try {
37727       (arg1)->MoveAbove(arg2);
37728     } catch (std::out_of_range& e) {
37729       {
37730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37731       };
37732     } catch (std::exception& e) {
37733       {
37734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37735       };
37736     } catch (Dali::DaliException e) {
37737       {
37738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37739       };
37740     } catch (...) {
37741       {
37742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37743       };
37744     }
37745   }
37746
37747 }
37748
37749
37750 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveBelow(void * jarg1, void * jarg2) {
37751   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37752   Dali::Layer arg2 ;
37753   Dali::Layer *argp2 ;
37754
37755   arg1 = (Dali::Layer *)jarg1;
37756   argp2 = (Dali::Layer *)jarg2;
37757   if (!argp2) {
37758     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37759     return ;
37760   }
37761   arg2 = *argp2;
37762   {
37763     try {
37764       (arg1)->MoveBelow(arg2);
37765     } catch (std::out_of_range& e) {
37766       {
37767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37768       };
37769     } catch (std::exception& e) {
37770       {
37771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37772       };
37773     } catch (Dali::DaliException e) {
37774       {
37775         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37776       };
37777     } catch (...) {
37778       {
37779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37780       };
37781     }
37782   }
37783
37784 }
37785
37786
37787 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetBehavior(void * jarg1, int jarg2) {
37788   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37789   Dali::Layer::Behavior arg2 ;
37790
37791   arg1 = (Dali::Layer *)jarg1;
37792   arg2 = (Dali::Layer::Behavior)jarg2;
37793   {
37794     try {
37795       (arg1)->SetBehavior(arg2);
37796     } catch (std::out_of_range& e) {
37797       {
37798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37799       };
37800     } catch (std::exception& e) {
37801       {
37802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37803       };
37804     } catch (Dali::DaliException e) {
37805       {
37806         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37807       };
37808     } catch (...) {
37809       {
37810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37811       };
37812     }
37813   }
37814
37815 }
37816
37817
37818 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_GetBehavior(void * jarg1) {
37819   int jresult ;
37820   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37821   Dali::Layer::Behavior result;
37822
37823   arg1 = (Dali::Layer *)jarg1;
37824   {
37825     try {
37826       result = (Dali::Layer::Behavior)((Dali::Layer const *)arg1)->GetBehavior();
37827     } catch (std::out_of_range& e) {
37828       {
37829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37830       };
37831     } catch (std::exception& e) {
37832       {
37833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37834       };
37835     } catch (Dali::DaliException e) {
37836       {
37837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37838       };
37839     } catch (...) {
37840       {
37841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37842       };
37843     }
37844   }
37845
37846   jresult = (int)result;
37847   return jresult;
37848 }
37849
37850
37851 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClipping(void * jarg1, unsigned int jarg2) {
37852   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37853   bool arg2 ;
37854
37855   arg1 = (Dali::Layer *)jarg1;
37856   arg2 = jarg2 ? true : false;
37857   {
37858     try {
37859       (arg1)->SetClipping(arg2);
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 unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsClipping(void * jarg1) {
37883   unsigned int jresult ;
37884   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37885   bool result;
37886
37887   arg1 = (Dali::Layer *)jarg1;
37888   {
37889     try {
37890       result = (bool)((Dali::Layer const *)arg1)->IsClipping();
37891     } catch (std::out_of_range& e) {
37892       {
37893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37894       };
37895     } catch (std::exception& e) {
37896       {
37897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37898       };
37899     } catch (Dali::DaliException e) {
37900       {
37901         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37902       };
37903     } catch (...) {
37904       {
37905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37906       };
37907     }
37908   }
37909
37910   jresult = result;
37911   return jresult;
37912 }
37913
37914
37915 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_0(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
37916   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37917   int arg2 ;
37918   int arg3 ;
37919   int arg4 ;
37920   int arg5 ;
37921
37922   arg1 = (Dali::Layer *)jarg1;
37923   arg2 = (int)jarg2;
37924   arg3 = (int)jarg3;
37925   arg4 = (int)jarg4;
37926   arg5 = (int)jarg5;
37927   {
37928     try {
37929       (arg1)->SetClippingBox(arg2,arg3,arg4,arg5);
37930     } catch (std::out_of_range& e) {
37931       {
37932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37933       };
37934     } catch (std::exception& e) {
37935       {
37936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37937       };
37938     } catch (Dali::DaliException e) {
37939       {
37940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37941       };
37942     } catch (...) {
37943       {
37944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37945       };
37946     }
37947   }
37948
37949 }
37950
37951
37952 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_1(void * jarg1, void * jarg2) {
37953   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37954   Dali::ClippingBox arg2 ;
37955   Dali::ClippingBox *argp2 ;
37956
37957   arg1 = (Dali::Layer *)jarg1;
37958   argp2 = (Dali::ClippingBox *)jarg2;
37959   if (!argp2) {
37960     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ClippingBox", 0);
37961     return ;
37962   }
37963   arg2 = *argp2;
37964   {
37965     try {
37966       (arg1)->SetClippingBox(arg2);
37967     } catch (std::out_of_range& e) {
37968       {
37969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37970       };
37971     } catch (std::exception& e) {
37972       {
37973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37974       };
37975     } catch (Dali::DaliException e) {
37976       {
37977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37978       };
37979     } catch (...) {
37980       {
37981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37982       };
37983     }
37984   }
37985
37986 }
37987
37988
37989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_GetClippingBox(void * jarg1) {
37990   void * jresult ;
37991   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37992   Dali::ClippingBox result;
37993
37994   arg1 = (Dali::Layer *)jarg1;
37995   {
37996     try {
37997       result = ((Dali::Layer const *)arg1)->GetClippingBox();
37998     } catch (std::out_of_range& e) {
37999       {
38000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38001       };
38002     } catch (std::exception& e) {
38003       {
38004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38005       };
38006     } catch (Dali::DaliException e) {
38007       {
38008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38009       };
38010     } catch (...) {
38011       {
38012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38013       };
38014     }
38015   }
38016
38017   jresult = new Dali::ClippingBox((const Dali::ClippingBox &)result);
38018   return jresult;
38019 }
38020
38021
38022 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetDepthTestDisabled(void * jarg1, unsigned int jarg2) {
38023   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38024   bool arg2 ;
38025
38026   arg1 = (Dali::Layer *)jarg1;
38027   arg2 = jarg2 ? true : false;
38028   {
38029     try {
38030       (arg1)->SetDepthTestDisabled(arg2);
38031     } catch (std::out_of_range& e) {
38032       {
38033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38034       };
38035     } catch (std::exception& e) {
38036       {
38037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38038       };
38039     } catch (Dali::DaliException e) {
38040       {
38041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38042       };
38043     } catch (...) {
38044       {
38045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38046       };
38047     }
38048   }
38049
38050 }
38051
38052
38053 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsDepthTestDisabled(void * jarg1) {
38054   unsigned int jresult ;
38055   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38056   bool result;
38057
38058   arg1 = (Dali::Layer *)jarg1;
38059   {
38060     try {
38061       result = (bool)((Dali::Layer const *)arg1)->IsDepthTestDisabled();
38062     } catch (std::out_of_range& e) {
38063       {
38064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38065       };
38066     } catch (std::exception& e) {
38067       {
38068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38069       };
38070     } catch (Dali::DaliException e) {
38071       {
38072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38073       };
38074     } catch (...) {
38075       {
38076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38077       };
38078     }
38079   }
38080
38081   jresult = result;
38082   return jresult;
38083 }
38084
38085
38086 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetSortFunction(void * jarg1, void * jarg2) {
38087   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38088   Dali::Layer::SortFunctionType arg2 = (Dali::Layer::SortFunctionType) 0 ;
38089
38090   arg1 = (Dali::Layer *)jarg1;
38091   arg2 = (Dali::Layer::SortFunctionType)jarg2;
38092   {
38093     try {
38094       (arg1)->SetSortFunction(arg2);
38095     } catch (std::out_of_range& e) {
38096       {
38097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38098       };
38099     } catch (std::exception& e) {
38100       {
38101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38102       };
38103     } catch (Dali::DaliException e) {
38104       {
38105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38106       };
38107     } catch (...) {
38108       {
38109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38110       };
38111     }
38112   }
38113
38114 }
38115
38116
38117 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetTouchConsumed(void * jarg1, unsigned int jarg2) {
38118   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38119   bool arg2 ;
38120
38121   arg1 = (Dali::Layer *)jarg1;
38122   arg2 = jarg2 ? true : false;
38123   {
38124     try {
38125       (arg1)->SetTouchConsumed(arg2);
38126     } catch (std::out_of_range& e) {
38127       {
38128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38129       };
38130     } catch (std::exception& e) {
38131       {
38132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38133       };
38134     } catch (Dali::DaliException e) {
38135       {
38136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38137       };
38138     } catch (...) {
38139       {
38140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38141       };
38142     }
38143   }
38144
38145 }
38146
38147
38148 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsTouchConsumed(void * jarg1) {
38149   unsigned int jresult ;
38150   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38151   bool result;
38152
38153   arg1 = (Dali::Layer *)jarg1;
38154   {
38155     try {
38156       result = (bool)((Dali::Layer const *)arg1)->IsTouchConsumed();
38157     } catch (std::out_of_range& e) {
38158       {
38159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38160       };
38161     } catch (std::exception& e) {
38162       {
38163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38164       };
38165     } catch (Dali::DaliException e) {
38166       {
38167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38168       };
38169     } catch (...) {
38170       {
38171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38172       };
38173     }
38174   }
38175
38176   jresult = result;
38177   return jresult;
38178 }
38179
38180
38181 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetHoverConsumed(void * jarg1, unsigned int jarg2) {
38182   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38183   bool arg2 ;
38184
38185   arg1 = (Dali::Layer *)jarg1;
38186   arg2 = jarg2 ? true : false;
38187   {
38188     try {
38189       (arg1)->SetHoverConsumed(arg2);
38190     } catch (std::out_of_range& e) {
38191       {
38192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38193       };
38194     } catch (std::exception& e) {
38195       {
38196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38197       };
38198     } catch (Dali::DaliException e) {
38199       {
38200         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38201       };
38202     } catch (...) {
38203       {
38204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38205       };
38206     }
38207   }
38208
38209 }
38210
38211
38212 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsHoverConsumed(void * jarg1) {
38213   unsigned int jresult ;
38214   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38215   bool result;
38216
38217   arg1 = (Dali::Layer *)jarg1;
38218   {
38219     try {
38220       result = (bool)((Dali::Layer const *)arg1)->IsHoverConsumed();
38221     } catch (std::out_of_range& e) {
38222       {
38223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38224       };
38225     } catch (std::exception& e) {
38226       {
38227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38228       };
38229     } catch (Dali::DaliException e) {
38230       {
38231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38232       };
38233     } catch (...) {
38234       {
38235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38236       };
38237     }
38238   }
38239
38240   jresult = result;
38241   return jresult;
38242 }
38243
38244
38245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEFAULT_BACKGROUND_COLOR_get() {
38246   void * jresult ;
38247   Dali::Vector4 *result = 0 ;
38248
38249   result = (Dali::Vector4 *)&Dali::Stage::DEFAULT_BACKGROUND_COLOR;
38250   jresult = (void *)result;
38251   return jresult;
38252 }
38253
38254
38255 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEBUG_BACKGROUND_COLOR_get() {
38256   void * jresult ;
38257   Dali::Vector4 *result = 0 ;
38258
38259   result = (Dali::Vector4 *)&Dali::Stage::DEBUG_BACKGROUND_COLOR;
38260   jresult = (void *)result;
38261   return jresult;
38262 }
38263
38264
38265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_0() {
38266   void * jresult ;
38267   Dali::Stage *result = 0 ;
38268
38269   {
38270     try {
38271       result = (Dali::Stage *)new Dali::Stage();
38272     } catch (std::out_of_range& e) {
38273       {
38274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38275       };
38276     } catch (std::exception& e) {
38277       {
38278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38279       };
38280     } catch (Dali::DaliException e) {
38281       {
38282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38283       };
38284     } catch (...) {
38285       {
38286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38287       };
38288     }
38289   }
38290
38291   jresult = (void *)result;
38292   return jresult;
38293 }
38294
38295
38296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetCurrent() {
38297   void * jresult ;
38298   Dali::Stage result;
38299
38300   {
38301     try {
38302       result = Dali::Stage::GetCurrent();
38303     } catch (std::out_of_range& e) {
38304       {
38305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38306       };
38307     } catch (std::exception& e) {
38308       {
38309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38310       };
38311     } catch (Dali::DaliException e) {
38312       {
38313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38314       };
38315     } catch (...) {
38316       {
38317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38318       };
38319     }
38320   }
38321
38322   jresult = new Dali::Stage((const Dali::Stage &)result);
38323   return jresult;
38324 }
38325
38326
38327 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_IsInstalled() {
38328   unsigned int jresult ;
38329   bool result;
38330
38331   {
38332     try {
38333       result = (bool)Dali::Stage::IsInstalled();
38334     } catch (std::out_of_range& e) {
38335       {
38336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38337       };
38338     } catch (std::exception& e) {
38339       {
38340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38341       };
38342     } catch (Dali::DaliException e) {
38343       {
38344         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38345       };
38346     } catch (...) {
38347       {
38348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38349       };
38350     }
38351   }
38352
38353   jresult = result;
38354   return jresult;
38355 }
38356
38357
38358 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Stage(void * jarg1) {
38359   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38360
38361   arg1 = (Dali::Stage *)jarg1;
38362   {
38363     try {
38364       delete arg1;
38365     } catch (std::out_of_range& e) {
38366       {
38367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38368       };
38369     } catch (std::exception& e) {
38370       {
38371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38372       };
38373     } catch (Dali::DaliException e) {
38374       {
38375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38376       };
38377     } catch (...) {
38378       {
38379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38380       };
38381     }
38382   }
38383
38384 }
38385
38386
38387 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_1(void * jarg1) {
38388   void * jresult ;
38389   Dali::Stage *arg1 = 0 ;
38390   Dali::Stage *result = 0 ;
38391
38392   arg1 = (Dali::Stage *)jarg1;
38393   if (!arg1) {
38394     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
38395     return 0;
38396   }
38397   {
38398     try {
38399       result = (Dali::Stage *)new Dali::Stage((Dali::Stage const &)*arg1);
38400     } catch (std::out_of_range& e) {
38401       {
38402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38403       };
38404     } catch (std::exception& e) {
38405       {
38406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38407       };
38408     } catch (Dali::DaliException e) {
38409       {
38410         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38411       };
38412     } catch (...) {
38413       {
38414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38415       };
38416     }
38417   }
38418
38419   jresult = (void *)result;
38420   return jresult;
38421 }
38422
38423
38424 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_Assign(void * jarg1, void * jarg2) {
38425   void * jresult ;
38426   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38427   Dali::Stage *arg2 = 0 ;
38428   Dali::Stage *result = 0 ;
38429
38430   arg1 = (Dali::Stage *)jarg1;
38431   arg2 = (Dali::Stage *)jarg2;
38432   if (!arg2) {
38433     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
38434     return 0;
38435   }
38436   {
38437     try {
38438       result = (Dali::Stage *) &(arg1)->operator =((Dali::Stage const &)*arg2);
38439     } catch (std::out_of_range& e) {
38440       {
38441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38442       };
38443     } catch (std::exception& e) {
38444       {
38445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38446       };
38447     } catch (Dali::DaliException e) {
38448       {
38449         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38450       };
38451     } catch (...) {
38452       {
38453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38454       };
38455     }
38456   }
38457
38458   jresult = (void *)result;
38459   return jresult;
38460 }
38461
38462
38463 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Add(void * jarg1, void * jarg2) {
38464   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38465   Dali::Actor *arg2 = 0 ;
38466
38467   arg1 = (Dali::Stage *)jarg1;
38468   arg2 = (Dali::Actor *)jarg2;
38469   if (!arg2) {
38470     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
38471     return ;
38472   }
38473   {
38474     try {
38475       (arg1)->Add(*arg2);
38476     } catch (std::out_of_range& e) {
38477       {
38478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38479       };
38480     } catch (std::exception& e) {
38481       {
38482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38483       };
38484     } catch (Dali::DaliException e) {
38485       {
38486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38487       };
38488     } catch (...) {
38489       {
38490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38491       };
38492     }
38493   }
38494
38495 }
38496
38497
38498 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Remove(void * jarg1, void * jarg2) {
38499   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38500   Dali::Actor *arg2 = 0 ;
38501
38502   arg1 = (Dali::Stage *)jarg1;
38503   arg2 = (Dali::Actor *)jarg2;
38504   if (!arg2) {
38505     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
38506     return ;
38507   }
38508   {
38509     try {
38510       (arg1)->Remove(*arg2);
38511     } catch (std::out_of_range& e) {
38512       {
38513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38514       };
38515     } catch (std::exception& e) {
38516       {
38517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38518       };
38519     } catch (Dali::DaliException e) {
38520       {
38521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38522       };
38523     } catch (...) {
38524       {
38525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38526       };
38527     }
38528   }
38529
38530 }
38531
38532
38533 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetSize(void * jarg1) {
38534   void * jresult ;
38535   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38536   Dali::Vector2 result;
38537
38538   arg1 = (Dali::Stage *)jarg1;
38539   {
38540     try {
38541       result = ((Dali::Stage const *)arg1)->GetSize();
38542     } catch (std::out_of_range& e) {
38543       {
38544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38545       };
38546     } catch (std::exception& e) {
38547       {
38548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38549       };
38550     } catch (Dali::DaliException e) {
38551       {
38552         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38553       };
38554     } catch (...) {
38555       {
38556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38557       };
38558     }
38559   }
38560
38561   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
38562   return jresult;
38563 }
38564
38565
38566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRenderTaskList(void * jarg1) {
38567   void * jresult ;
38568   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38569   Dali::RenderTaskList result;
38570
38571   arg1 = (Dali::Stage *)jarg1;
38572   {
38573     try {
38574       result = ((Dali::Stage const *)arg1)->GetRenderTaskList();
38575     } catch (std::out_of_range& e) {
38576       {
38577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38578       };
38579     } catch (std::exception& e) {
38580       {
38581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38582       };
38583     } catch (Dali::DaliException e) {
38584       {
38585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38586       };
38587     } catch (...) {
38588       {
38589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38590       };
38591     }
38592   }
38593
38594   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
38595   return jresult;
38596 }
38597
38598
38599 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_GetLayerCount(void * jarg1) {
38600   unsigned int jresult ;
38601   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38602   unsigned int result;
38603
38604   arg1 = (Dali::Stage *)jarg1;
38605   {
38606     try {
38607       result = (unsigned int)((Dali::Stage const *)arg1)->GetLayerCount();
38608     } catch (std::out_of_range& e) {
38609       {
38610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38611       };
38612     } catch (std::exception& e) {
38613       {
38614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38615       };
38616     } catch (Dali::DaliException e) {
38617       {
38618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38619       };
38620     } catch (...) {
38621       {
38622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38623       };
38624     }
38625   }
38626
38627   jresult = result;
38628   return jresult;
38629 }
38630
38631
38632 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetLayer(void * jarg1, unsigned int jarg2) {
38633   void * jresult ;
38634   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38635   unsigned int arg2 ;
38636   Dali::Layer result;
38637
38638   arg1 = (Dali::Stage *)jarg1;
38639   arg2 = (unsigned int)jarg2;
38640   {
38641     try {
38642       result = ((Dali::Stage const *)arg1)->GetLayer(arg2);
38643     } catch (std::out_of_range& e) {
38644       {
38645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38646       };
38647     } catch (std::exception& e) {
38648       {
38649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38650       };
38651     } catch (Dali::DaliException e) {
38652       {
38653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38654       };
38655     } catch (...) {
38656       {
38657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38658       };
38659     }
38660   }
38661
38662   jresult = new Dali::Layer((const Dali::Layer &)result);
38663   return jresult;
38664 }
38665
38666
38667 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRootLayer(void * jarg1) {
38668   void * jresult ;
38669   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38670   Dali::Layer result;
38671
38672   arg1 = (Dali::Stage *)jarg1;
38673   {
38674     try {
38675       result = ((Dali::Stage const *)arg1)->GetRootLayer();
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::Layer((const Dali::Layer &)result);
38696   return jresult;
38697 }
38698
38699
38700 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetBackgroundColor(void * jarg1, void * jarg2) {
38701   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38702   Dali::Vector4 arg2 ;
38703   Dali::Vector4 *argp2 ;
38704
38705   arg1 = (Dali::Stage *)jarg1;
38706   argp2 = (Dali::Vector4 *)jarg2;
38707   if (!argp2) {
38708     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector4", 0);
38709     return ;
38710   }
38711   arg2 = *argp2;
38712   {
38713     try {
38714       (arg1)->SetBackgroundColor(arg2);
38715     } catch (std::out_of_range& e) {
38716       {
38717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38718       };
38719     } catch (std::exception& e) {
38720       {
38721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38722       };
38723     } catch (Dali::DaliException e) {
38724       {
38725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38726       };
38727     } catch (...) {
38728       {
38729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38730       };
38731     }
38732   }
38733
38734 }
38735
38736
38737 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetBackgroundColor(void * jarg1) {
38738   void * jresult ;
38739   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38740   Dali::Vector4 result;
38741
38742   arg1 = (Dali::Stage *)jarg1;
38743   {
38744     try {
38745       result = ((Dali::Stage const *)arg1)->GetBackgroundColor();
38746     } catch (std::out_of_range& e) {
38747       {
38748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38749       };
38750     } catch (std::exception& e) {
38751       {
38752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38753       };
38754     } catch (Dali::DaliException e) {
38755       {
38756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38757       };
38758     } catch (...) {
38759       {
38760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38761       };
38762     }
38763   }
38764
38765   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
38766   return jresult;
38767 }
38768
38769
38770 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetDpi(void * jarg1) {
38771   void * jresult ;
38772   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38773   Dali::Vector2 result;
38774
38775   arg1 = (Dali::Stage *)jarg1;
38776   {
38777     try {
38778       result = ((Dali::Stage const *)arg1)->GetDpi();
38779     } catch (std::out_of_range& e) {
38780       {
38781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38782       };
38783     } catch (std::exception& e) {
38784       {
38785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38786       };
38787     } catch (Dali::DaliException e) {
38788       {
38789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38790       };
38791     } catch (...) {
38792       {
38793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38794       };
38795     }
38796   }
38797
38798   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
38799   return jresult;
38800 }
38801
38802
38803 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetObjectRegistry(void * jarg1) {
38804   void * jresult ;
38805   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38806   Dali::ObjectRegistry result;
38807
38808   arg1 = (Dali::Stage *)jarg1;
38809   {
38810     try {
38811       result = ((Dali::Stage const *)arg1)->GetObjectRegistry();
38812     } catch (std::out_of_range& e) {
38813       {
38814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38815       };
38816     } catch (std::exception& e) {
38817       {
38818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38819       };
38820     } catch (Dali::DaliException e) {
38821       {
38822         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38823       };
38824     } catch (...) {
38825       {
38826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38827       };
38828     }
38829   }
38830
38831   jresult = new Dali::ObjectRegistry((const Dali::ObjectRegistry &)result);
38832   return jresult;
38833 }
38834
38835
38836 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_KeepRendering(void * jarg1, float jarg2) {
38837   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38838   float arg2 ;
38839
38840   arg1 = (Dali::Stage *)jarg1;
38841   arg2 = (float)jarg2;
38842   {
38843     try {
38844       (arg1)->KeepRendering(arg2);
38845     } catch (std::out_of_range& e) {
38846       {
38847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38848       };
38849     } catch (std::exception& e) {
38850       {
38851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38852       };
38853     } catch (Dali::DaliException e) {
38854       {
38855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38856       };
38857     } catch (...) {
38858       {
38859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38860       };
38861     }
38862   }
38863
38864 }
38865
38866
38867 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_KeyEventSignal(void * jarg1) {
38868   void * jresult ;
38869   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38870   Dali::Stage::KeyEventSignalType *result = 0 ;
38871
38872   arg1 = (Dali::Stage *)jarg1;
38873   {
38874     try {
38875       result = (Dali::Stage::KeyEventSignalType *) &(arg1)->KeyEventSignal();
38876     } catch (std::out_of_range& e) {
38877       {
38878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38879       };
38880     } catch (std::exception& e) {
38881       {
38882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38883       };
38884     } catch (Dali::DaliException e) {
38885       {
38886         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38887       };
38888     } catch (...) {
38889       {
38890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38891       };
38892     }
38893   }
38894
38895   jresult = (void *)result;
38896   return jresult;
38897 }
38898
38899
38900 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_EventProcessingFinishedSignal(void * jarg1) {
38901   void * jresult ;
38902   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38903   Dali::Stage::EventProcessingFinishedSignalType *result = 0 ;
38904
38905   arg1 = (Dali::Stage *)jarg1;
38906   {
38907     try {
38908       result = (Dali::Stage::EventProcessingFinishedSignalType *) &(arg1)->EventProcessingFinishedSignal();
38909     } catch (std::out_of_range& e) {
38910       {
38911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38912       };
38913     } catch (std::exception& e) {
38914       {
38915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38916       };
38917     } catch (Dali::DaliException e) {
38918       {
38919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38920       };
38921     } catch (...) {
38922       {
38923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38924       };
38925     }
38926   }
38927
38928   jresult = (void *)result;
38929   return jresult;
38930 }
38931
38932
38933 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_TouchSignal(void * jarg1) {
38934   void * jresult ;
38935   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38936   Dali::Stage::TouchSignalType *result = 0 ;
38937
38938   arg1 = (Dali::Stage *)jarg1;
38939   {
38940     try {
38941       result = (Dali::Stage::TouchSignalType *) &(arg1)->TouchSignal();
38942     } catch (std::out_of_range& e) {
38943       {
38944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38945       };
38946     } catch (std::exception& e) {
38947       {
38948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38949       };
38950     } catch (Dali::DaliException e) {
38951       {
38952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38953       };
38954     } catch (...) {
38955       {
38956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38957       };
38958     }
38959   }
38960
38961   jresult = (void *)result;
38962   return jresult;
38963 }
38964
38965
38966 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_WheelEventSignal(void * jarg1) {
38967   void * jresult ;
38968   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38969   Dali::Stage::WheelEventSignalType *result = 0 ;
38970
38971   arg1 = (Dali::Stage *)jarg1;
38972   {
38973     try {
38974       result = (Dali::Stage::WheelEventSignalType *) &(arg1)->WheelEventSignal();
38975     } catch (std::out_of_range& e) {
38976       {
38977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38978       };
38979     } catch (std::exception& e) {
38980       {
38981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38982       };
38983     } catch (Dali::DaliException e) {
38984       {
38985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38986       };
38987     } catch (...) {
38988       {
38989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38990       };
38991     }
38992   }
38993
38994   jresult = (void *)result;
38995   return jresult;
38996 }
38997
38998
38999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextLostSignal(void * jarg1) {
39000   void * jresult ;
39001   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39002   Dali::Stage::ContextStatusSignal *result = 0 ;
39003
39004   arg1 = (Dali::Stage *)jarg1;
39005   {
39006     try {
39007       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextLostSignal();
39008     } catch (std::out_of_range& e) {
39009       {
39010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39011       };
39012     } catch (std::exception& e) {
39013       {
39014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39015       };
39016     } catch (Dali::DaliException e) {
39017       {
39018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39019       };
39020     } catch (...) {
39021       {
39022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39023       };
39024     }
39025   }
39026
39027   jresult = (void *)result;
39028   return jresult;
39029 }
39030
39031
39032 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextRegainedSignal(void * jarg1) {
39033   void * jresult ;
39034   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39035   Dali::Stage::ContextStatusSignal *result = 0 ;
39036
39037   arg1 = (Dali::Stage *)jarg1;
39038   {
39039     try {
39040       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextRegainedSignal();
39041     } catch (std::out_of_range& e) {
39042       {
39043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39044       };
39045     } catch (std::exception& e) {
39046       {
39047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39048       };
39049     } catch (Dali::DaliException e) {
39050       {
39051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39052       };
39053     } catch (...) {
39054       {
39055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39056       };
39057     }
39058   }
39059
39060   jresult = (void *)result;
39061   return jresult;
39062 }
39063
39064
39065 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_SceneCreatedSignal(void * jarg1) {
39066   void * jresult ;
39067   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39068   Dali::Stage::SceneCreatedSignalType *result = 0 ;
39069
39070   arg1 = (Dali::Stage *)jarg1;
39071   {
39072     try {
39073       result = (Dali::Stage::SceneCreatedSignalType *) &(arg1)->SceneCreatedSignal();
39074     } catch (std::out_of_range& e) {
39075       {
39076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39077       };
39078     } catch (std::exception& e) {
39079       {
39080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39081       };
39082     } catch (Dali::DaliException e) {
39083       {
39084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39085       };
39086     } catch (...) {
39087       {
39088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39089       };
39090     }
39091   }
39092
39093   jresult = (void *)result;
39094   return jresult;
39095 }
39096
39097
39098 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RelayoutContainer(void * jarg1) {
39099   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
39100
39101   arg1 = (Dali::RelayoutContainer *)jarg1;
39102   {
39103     try {
39104       delete arg1;
39105     } catch (std::out_of_range& e) {
39106       {
39107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39108       };
39109     } catch (std::exception& e) {
39110       {
39111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39112       };
39113     } catch (Dali::DaliException e) {
39114       {
39115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39116       };
39117     } catch (...) {
39118       {
39119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39120       };
39121     }
39122   }
39123
39124 }
39125
39126
39127 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RelayoutContainer_Add(void * jarg1, void * jarg2, void * jarg3) {
39128   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
39129   Dali::Actor *arg2 = 0 ;
39130   Dali::Vector2 *arg3 = 0 ;
39131
39132   arg1 = (Dali::RelayoutContainer *)jarg1;
39133   arg2 = (Dali::Actor *)jarg2;
39134   if (!arg2) {
39135     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
39136     return ;
39137   }
39138   arg3 = (Dali::Vector2 *)jarg3;
39139   if (!arg3) {
39140     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
39141     return ;
39142   }
39143   {
39144     try {
39145       (arg1)->Add((Dali::Actor const &)*arg2,(Dali::Vector2 const &)*arg3);
39146     } catch (std::out_of_range& e) {
39147       {
39148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39149       };
39150     } catch (std::exception& e) {
39151       {
39152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39153       };
39154     } catch (Dali::DaliException e) {
39155       {
39156         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39157       };
39158     } catch (...) {
39159       {
39160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39161       };
39162     }
39163   }
39164
39165 }
39166
39167
39168 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_Self(void * jarg1) {
39169   void * jresult ;
39170   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39171   Dali::CustomActor result;
39172
39173   arg1 = (Dali::CustomActorImpl *)jarg1;
39174   {
39175     try {
39176       result = ((Dali::CustomActorImpl const *)arg1)->Self();
39177     } catch (std::out_of_range& e) {
39178       {
39179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39180       };
39181     } catch (std::exception& e) {
39182       {
39183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39184       };
39185     } catch (Dali::DaliException e) {
39186       {
39187         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39188       };
39189     } catch (...) {
39190       {
39191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39192       };
39193     }
39194   }
39195
39196   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
39197   return jresult;
39198 }
39199
39200
39201 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageConnection(void * jarg1, int jarg2) {
39202   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39203   int arg2 ;
39204
39205   arg1 = (Dali::CustomActorImpl *)jarg1;
39206   arg2 = (int)jarg2;
39207   {
39208     try {
39209       (arg1)->OnStageConnection(arg2);
39210     } catch (std::out_of_range& e) {
39211       {
39212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39213       };
39214     } catch (std::exception& e) {
39215       {
39216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39217       };
39218     } catch (Dali::DaliException e) {
39219       {
39220         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39221       };
39222     } catch (...) {
39223       {
39224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39225       };
39226     }
39227   }
39228
39229 }
39230
39231
39232 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageDisconnection(void * jarg1) {
39233   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39234
39235   arg1 = (Dali::CustomActorImpl *)jarg1;
39236   {
39237     try {
39238       (arg1)->OnStageDisconnection();
39239     } catch (std::out_of_range& e) {
39240       {
39241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39242       };
39243     } catch (std::exception& e) {
39244       {
39245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39246       };
39247     } catch (Dali::DaliException e) {
39248       {
39249         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39250       };
39251     } catch (...) {
39252       {
39253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39254       };
39255     }
39256   }
39257
39258 }
39259
39260
39261 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildAdd(void * jarg1, void * jarg2) {
39262   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39263   Dali::Actor *arg2 = 0 ;
39264
39265   arg1 = (Dali::CustomActorImpl *)jarg1;
39266   arg2 = (Dali::Actor *)jarg2;
39267   if (!arg2) {
39268     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
39269     return ;
39270   }
39271   {
39272     try {
39273       (arg1)->OnChildAdd(*arg2);
39274     } catch (std::out_of_range& e) {
39275       {
39276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39277       };
39278     } catch (std::exception& e) {
39279       {
39280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39281       };
39282     } catch (Dali::DaliException e) {
39283       {
39284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39285       };
39286     } catch (...) {
39287       {
39288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39289       };
39290     }
39291   }
39292
39293 }
39294
39295
39296 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildRemove(void * jarg1, void * jarg2) {
39297   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39298   Dali::Actor *arg2 = 0 ;
39299
39300   arg1 = (Dali::CustomActorImpl *)jarg1;
39301   arg2 = (Dali::Actor *)jarg2;
39302   if (!arg2) {
39303     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
39304     return ;
39305   }
39306   {
39307     try {
39308       (arg1)->OnChildRemove(*arg2);
39309     } catch (std::out_of_range& e) {
39310       {
39311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39312       };
39313     } catch (std::exception& e) {
39314       {
39315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39316       };
39317     } catch (Dali::DaliException e) {
39318       {
39319         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39320       };
39321     } catch (...) {
39322       {
39323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39324       };
39325     }
39326   }
39327
39328 }
39329
39330
39331 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
39332   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39333   Dali::Property::Index arg2 ;
39334   Dali::Property::Value arg3 ;
39335   Dali::Property::Value *argp3 ;
39336
39337   arg1 = (Dali::CustomActorImpl *)jarg1;
39338   arg2 = (Dali::Property::Index)jarg2;
39339   argp3 = (Dali::Property::Value *)jarg3;
39340   if (!argp3) {
39341     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39342     return ;
39343   }
39344   arg3 = *argp3;
39345   {
39346     try {
39347       (arg1)->OnPropertySet(arg2,arg3);
39348     } catch (std::out_of_range& e) {
39349       {
39350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39351       };
39352     } catch (std::exception& e) {
39353       {
39354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39355       };
39356     } catch (Dali::DaliException e) {
39357       {
39358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39359       };
39360     } catch (...) {
39361       {
39362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39363       };
39364     }
39365   }
39366
39367 }
39368
39369
39370 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeSet(void * jarg1, void * jarg2) {
39371   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39372   Dali::Vector3 *arg2 = 0 ;
39373
39374   arg1 = (Dali::CustomActorImpl *)jarg1;
39375   arg2 = (Dali::Vector3 *)jarg2;
39376   if (!arg2) {
39377     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
39378     return ;
39379   }
39380   {
39381     try {
39382       (arg1)->OnSizeSet((Dali::Vector3 const &)*arg2);
39383     } catch (std::out_of_range& e) {
39384       {
39385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39386       };
39387     } catch (std::exception& e) {
39388       {
39389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39390       };
39391     } catch (Dali::DaliException e) {
39392       {
39393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39394       };
39395     } catch (...) {
39396       {
39397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39398       };
39399     }
39400   }
39401
39402 }
39403
39404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
39405   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39406   Dali::Animation *arg2 = 0 ;
39407   Dali::Vector3 *arg3 = 0 ;
39408
39409   arg1 = (Dali::CustomActorImpl *)jarg1;
39410   arg2 = (Dali::Animation *)jarg2;
39411   if (!arg2) {
39412     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
39413     return ;
39414   }
39415   arg3 = (Dali::Vector3 *)jarg3;
39416   if (!arg3) {
39417     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
39418     return ;
39419   }
39420   {
39421     try {
39422       (arg1)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
39423     } catch (std::out_of_range& e) {
39424       {
39425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39426       };
39427     } catch (std::exception& e) {
39428       {
39429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39430       };
39431     } catch (Dali::DaliException e) {
39432       {
39433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39434       };
39435     } catch (...) {
39436       {
39437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39438       };
39439     }
39440   }
39441
39442 }
39443
39444
39445 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnTouchEvent(void * jarg1, void * jarg2) {
39446   unsigned int jresult ;
39447   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39448   Dali::TouchEvent *arg2 = 0 ;
39449   bool result;
39450
39451   arg1 = (Dali::CustomActorImpl *)jarg1;
39452   arg2 = (Dali::TouchEvent *)jarg2;
39453   if (!arg2) {
39454     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
39455     return 0;
39456   }
39457   {
39458     try {
39459       result = (bool)(arg1)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
39460     } catch (std::out_of_range& e) {
39461       {
39462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39463       };
39464     } catch (std::exception& e) {
39465       {
39466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39467       };
39468     } catch (Dali::DaliException e) {
39469       {
39470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39471       };
39472     } catch (...) {
39473       {
39474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39475       };
39476     }
39477   }
39478
39479   jresult = result;
39480   return jresult;
39481 }
39482
39483
39484 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnHoverEvent(void * jarg1, void * jarg2) {
39485   unsigned int jresult ;
39486   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39487   Dali::HoverEvent *arg2 = 0 ;
39488   bool result;
39489
39490   arg1 = (Dali::CustomActorImpl *)jarg1;
39491   arg2 = (Dali::HoverEvent *)jarg2;
39492   if (!arg2) {
39493     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
39494     return 0;
39495   }
39496   {
39497     try {
39498       result = (bool)(arg1)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
39499     } catch (std::out_of_range& e) {
39500       {
39501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39502       };
39503     } catch (std::exception& e) {
39504       {
39505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39506       };
39507     } catch (Dali::DaliException e) {
39508       {
39509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39510       };
39511     } catch (...) {
39512       {
39513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39514       };
39515     }
39516   }
39517
39518   jresult = result;
39519   return jresult;
39520 }
39521
39522
39523 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnKeyEvent(void * jarg1, void * jarg2) {
39524   unsigned int jresult ;
39525   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39526   Dali::KeyEvent *arg2 = 0 ;
39527   bool result;
39528
39529   arg1 = (Dali::CustomActorImpl *)jarg1;
39530   arg2 = (Dali::KeyEvent *)jarg2;
39531   if (!arg2) {
39532     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
39533     return 0;
39534   }
39535   {
39536     try {
39537       result = (bool)(arg1)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
39538     } catch (std::out_of_range& e) {
39539       {
39540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39541       };
39542     } catch (std::exception& e) {
39543       {
39544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39545       };
39546     } catch (Dali::DaliException e) {
39547       {
39548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39549       };
39550     } catch (...) {
39551       {
39552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39553       };
39554     }
39555   }
39556
39557   jresult = result;
39558   return jresult;
39559 }
39560
39561
39562 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnWheelEvent(void * jarg1, void * jarg2) {
39563   unsigned int jresult ;
39564   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39565   Dali::WheelEvent *arg2 = 0 ;
39566   bool result;
39567
39568   arg1 = (Dali::CustomActorImpl *)jarg1;
39569   arg2 = (Dali::WheelEvent *)jarg2;
39570   if (!arg2) {
39571     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
39572     return 0;
39573   }
39574   {
39575     try {
39576       result = (bool)(arg1)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
39577     } catch (std::out_of_range& e) {
39578       {
39579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39580       };
39581     } catch (std::exception& e) {
39582       {
39583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39584       };
39585     } catch (Dali::DaliException e) {
39586       {
39587         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39588       };
39589     } catch (...) {
39590       {
39591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39592       };
39593     }
39594   }
39595
39596   jresult = result;
39597   return jresult;
39598 }
39599
39600
39601 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
39602   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39603   Dali::Vector2 *arg2 = 0 ;
39604   Dali::RelayoutContainer *arg3 = 0 ;
39605
39606   arg1 = (Dali::CustomActorImpl *)jarg1;
39607   arg2 = (Dali::Vector2 *)jarg2;
39608   if (!arg2) {
39609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
39610     return ;
39611   }
39612   arg3 = (Dali::RelayoutContainer *)jarg3;
39613   if (!arg3) {
39614     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
39615     return ;
39616   }
39617   {
39618     try {
39619       (arg1)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
39620     } catch (std::out_of_range& e) {
39621       {
39622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39623       };
39624     } catch (std::exception& e) {
39625       {
39626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39627       };
39628     } catch (Dali::DaliException e) {
39629       {
39630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39631       };
39632     } catch (...) {
39633       {
39634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39635       };
39636     }
39637   }
39638
39639 }
39640
39641
39642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
39643   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39644   Dali::ResizePolicy::Type arg2 ;
39645   Dali::Dimension::Type arg3 ;
39646
39647   arg1 = (Dali::CustomActorImpl *)jarg1;
39648   arg2 = (Dali::ResizePolicy::Type)jarg2;
39649   arg3 = (Dali::Dimension::Type)jarg3;
39650   {
39651     try {
39652       (arg1)->OnSetResizePolicy(arg2,arg3);
39653     } catch (std::out_of_range& e) {
39654       {
39655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39656       };
39657     } catch (std::exception& e) {
39658       {
39659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39660       };
39661     } catch (Dali::DaliException e) {
39662       {
39663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39664       };
39665     } catch (...) {
39666       {
39667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39668       };
39669     }
39670   }
39671
39672 }
39673
39674
39675 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetNaturalSize(void * jarg1) {
39676   void * jresult ;
39677   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39678   Dali::Vector3 result;
39679
39680   arg1 = (Dali::CustomActorImpl *)jarg1;
39681   {
39682     try {
39683       result = (arg1)->GetNaturalSize();
39684     } catch (std::out_of_range& e) {
39685       {
39686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39687       };
39688     } catch (std::exception& e) {
39689       {
39690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39691       };
39692     } catch (Dali::DaliException e) {
39693       {
39694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39695       };
39696     } catch (...) {
39697       {
39698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39699       };
39700     }
39701   }
39702
39703   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
39704   return jresult;
39705 }
39706
39707
39708 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
39709   float jresult ;
39710   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39711   Dali::Actor *arg2 = 0 ;
39712   Dali::Dimension::Type arg3 ;
39713   float result;
39714
39715   arg1 = (Dali::CustomActorImpl *)jarg1;
39716   arg2 = (Dali::Actor *)jarg2;
39717   if (!arg2) {
39718     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
39719     return 0;
39720   }
39721   arg3 = (Dali::Dimension::Type)jarg3;
39722   {
39723     try {
39724       result = (float)(arg1)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
39725     } catch (std::out_of_range& e) {
39726       {
39727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39728       };
39729     } catch (std::exception& e) {
39730       {
39731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39732       };
39733     } catch (Dali::DaliException e) {
39734       {
39735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39736       };
39737     } catch (...) {
39738       {
39739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39740       };
39741     }
39742   }
39743
39744   jresult = result;
39745   return jresult;
39746 }
39747
39748
39749 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetHeightForWidth(void * jarg1, float jarg2) {
39750   float jresult ;
39751   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39752   float arg2 ;
39753   float result;
39754
39755   arg1 = (Dali::CustomActorImpl *)jarg1;
39756   arg2 = (float)jarg2;
39757   {
39758     try {
39759       result = (float)(arg1)->GetHeightForWidth(arg2);
39760     } catch (std::out_of_range& e) {
39761       {
39762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39763       };
39764     } catch (std::exception& e) {
39765       {
39766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39767       };
39768     } catch (Dali::DaliException e) {
39769       {
39770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39771       };
39772     } catch (...) {
39773       {
39774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39775       };
39776     }
39777   }
39778
39779   jresult = result;
39780   return jresult;
39781 }
39782
39783
39784 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetWidthForHeight(void * jarg1, float jarg2) {
39785   float jresult ;
39786   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39787   float arg2 ;
39788   float result;
39789
39790   arg1 = (Dali::CustomActorImpl *)jarg1;
39791   arg2 = (float)jarg2;
39792   {
39793     try {
39794       result = (float)(arg1)->GetWidthForHeight(arg2);
39795     } catch (std::out_of_range& e) {
39796       {
39797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39798       };
39799     } catch (std::exception& e) {
39800       {
39801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39802       };
39803     } catch (Dali::DaliException e) {
39804       {
39805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39806       };
39807     } catch (...) {
39808       {
39809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39810       };
39811     }
39812   }
39813
39814   jresult = result;
39815   return jresult;
39816 }
39817
39818
39819 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
39820   unsigned int jresult ;
39821   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39822   Dali::Dimension::Type arg2 ;
39823   bool result;
39824
39825   arg1 = (Dali::CustomActorImpl *)jarg1;
39826   arg2 = (Dali::Dimension::Type)jarg2;
39827   {
39828     try {
39829       result = (bool)(arg1)->RelayoutDependentOnChildren(arg2);
39830     } catch (std::out_of_range& e) {
39831       {
39832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39833       };
39834     } catch (std::exception& e) {
39835       {
39836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39837       };
39838     } catch (Dali::DaliException e) {
39839       {
39840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39841       };
39842     } catch (...) {
39843       {
39844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39845       };
39846     }
39847   }
39848
39849   jresult = result;
39850   return jresult;
39851 }
39852
39853
39854 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
39855   unsigned int jresult ;
39856   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39857   bool result;
39858
39859   arg1 = (Dali::CustomActorImpl *)jarg1;
39860   {
39861     try {
39862       result = (bool)(arg1)->RelayoutDependentOnChildren();
39863     } catch (std::out_of_range& e) {
39864       {
39865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39866       };
39867     } catch (std::exception& e) {
39868       {
39869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39870       };
39871     } catch (Dali::DaliException e) {
39872       {
39873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39874       };
39875     } catch (...) {
39876       {
39877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39878       };
39879     }
39880   }
39881
39882   jresult = result;
39883   return jresult;
39884 }
39885
39886
39887 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
39888   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39889   Dali::Dimension::Type arg2 ;
39890
39891   arg1 = (Dali::CustomActorImpl *)jarg1;
39892   arg2 = (Dali::Dimension::Type)jarg2;
39893   {
39894     try {
39895       (arg1)->OnCalculateRelayoutSize(arg2);
39896     } catch (std::out_of_range& e) {
39897       {
39898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39899       };
39900     } catch (std::exception& e) {
39901       {
39902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39903       };
39904     } catch (Dali::DaliException e) {
39905       {
39906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39907       };
39908     } catch (...) {
39909       {
39910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39911       };
39912     }
39913   }
39914
39915 }
39916
39917
39918 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
39919   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39920   float arg2 ;
39921   Dali::Dimension::Type arg3 ;
39922
39923   arg1 = (Dali::CustomActorImpl *)jarg1;
39924   arg2 = (float)jarg2;
39925   arg3 = (Dali::Dimension::Type)jarg3;
39926   {
39927     try {
39928       (arg1)->OnLayoutNegotiated(arg2,arg3);
39929     } catch (std::out_of_range& e) {
39930       {
39931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39932       };
39933     } catch (std::exception& e) {
39934       {
39935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39936       };
39937     } catch (Dali::DaliException e) {
39938       {
39939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39940       };
39941     } catch (...) {
39942       {
39943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39944       };
39945     }
39946   }
39947
39948 }
39949
39950
39951 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresTouchEvents(void * jarg1) {
39952   unsigned int jresult ;
39953   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39954   bool result;
39955
39956   arg1 = (Dali::CustomActorImpl *)jarg1;
39957   {
39958     try {
39959       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresTouchEvents();
39960     } catch (std::out_of_range& e) {
39961       {
39962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39963       };
39964     } catch (std::exception& e) {
39965       {
39966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39967       };
39968     } catch (Dali::DaliException e) {
39969       {
39970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39971       };
39972     } catch (...) {
39973       {
39974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39975       };
39976     }
39977   }
39978
39979   jresult = result;
39980   return jresult;
39981 }
39982
39983
39984 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresHoverEvents(void * jarg1) {
39985   unsigned int jresult ;
39986   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39987   bool result;
39988
39989   arg1 = (Dali::CustomActorImpl *)jarg1;
39990   {
39991     try {
39992       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresHoverEvents();
39993     } catch (std::out_of_range& e) {
39994       {
39995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39996       };
39997     } catch (std::exception& e) {
39998       {
39999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40000       };
40001     } catch (Dali::DaliException e) {
40002       {
40003         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40004       };
40005     } catch (...) {
40006       {
40007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40008       };
40009     }
40010   }
40011
40012   jresult = result;
40013   return jresult;
40014 }
40015
40016
40017 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresWheelEvents(void * jarg1) {
40018   unsigned int jresult ;
40019   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
40020   bool result;
40021
40022   arg1 = (Dali::CustomActorImpl *)jarg1;
40023   {
40024     try {
40025       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresWheelEvents();
40026     } catch (std::out_of_range& e) {
40027       {
40028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40029       };
40030     } catch (std::exception& e) {
40031       {
40032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40033       };
40034     } catch (Dali::DaliException e) {
40035       {
40036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40037       };
40038     } catch (...) {
40039       {
40040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40041       };
40042     }
40043   }
40044
40045   jresult = result;
40046   return jresult;
40047 }
40048
40049
40050 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_IsRelayoutEnabled(void * jarg1) {
40051   unsigned int jresult ;
40052   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
40053   bool result;
40054
40055   arg1 = (Dali::CustomActorImpl *)jarg1;
40056   {
40057     try {
40058       result = (bool)((Dali::CustomActorImpl const *)arg1)->IsRelayoutEnabled();
40059     } catch (std::out_of_range& e) {
40060       {
40061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40062       };
40063     } catch (std::exception& e) {
40064       {
40065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40066       };
40067     } catch (Dali::DaliException e) {
40068       {
40069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40070       };
40071     } catch (...) {
40072       {
40073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40074       };
40075     }
40076   }
40077
40078   jresult = result;
40079   return jresult;
40080 }
40081
40082
40083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_0() {
40084   void * jresult ;
40085   Dali::CustomActor *result = 0 ;
40086
40087   {
40088     try {
40089       result = (Dali::CustomActor *)new Dali::CustomActor();
40090     } catch (std::out_of_range& e) {
40091       {
40092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40093       };
40094     } catch (std::exception& e) {
40095       {
40096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40097       };
40098     } catch (Dali::DaliException e) {
40099       {
40100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40101       };
40102     } catch (...) {
40103       {
40104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40105       };
40106     }
40107   }
40108
40109   jresult = (void *)result;
40110   return jresult;
40111 }
40112
40113
40114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_DownCast(void * jarg1) {
40115   void * jresult ;
40116   Dali::BaseHandle arg1 ;
40117   Dali::BaseHandle *argp1 ;
40118   Dali::CustomActor result;
40119
40120   argp1 = (Dali::BaseHandle *)jarg1;
40121   if (!argp1) {
40122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40123     return 0;
40124   }
40125   arg1 = *argp1;
40126   {
40127     try {
40128       result = Dali::CustomActor::DownCast(arg1);
40129     } catch (std::out_of_range& e) {
40130       {
40131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40132       };
40133     } catch (std::exception& e) {
40134       {
40135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40136       };
40137     } catch (Dali::DaliException e) {
40138       {
40139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40140       };
40141     } catch (...) {
40142       {
40143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40144       };
40145     }
40146   }
40147
40148   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
40149   return jresult;
40150 }
40151
40152
40153 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomActor(void * jarg1) {
40154   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
40155
40156   arg1 = (Dali::CustomActor *)jarg1;
40157   {
40158     try {
40159       delete arg1;
40160     } catch (std::out_of_range& e) {
40161       {
40162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40163       };
40164     } catch (std::exception& e) {
40165       {
40166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40167       };
40168     } catch (Dali::DaliException e) {
40169       {
40170         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40171       };
40172     } catch (...) {
40173       {
40174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40175       };
40176     }
40177   }
40178
40179 }
40180
40181
40182 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_GetImplementation(void * jarg1) {
40183   void * jresult ;
40184   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
40185   Dali::CustomActorImpl *result = 0 ;
40186
40187   arg1 = (Dali::CustomActor *)jarg1;
40188   {
40189     try {
40190       result = (Dali::CustomActorImpl *) &((Dali::CustomActor const *)arg1)->GetImplementation();
40191     } catch (std::out_of_range& e) {
40192       {
40193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40194       };
40195     } catch (std::exception& e) {
40196       {
40197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40198       };
40199     } catch (Dali::DaliException e) {
40200       {
40201         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40202       };
40203     } catch (...) {
40204       {
40205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40206       };
40207     }
40208   }
40209
40210   jresult = (void *)result;
40211   return jresult;
40212 }
40213
40214
40215 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_1(void * jarg1) {
40216   void * jresult ;
40217   Dali::CustomActorImpl *arg1 = 0 ;
40218   Dali::CustomActor *result = 0 ;
40219
40220   arg1 = (Dali::CustomActorImpl *)jarg1;
40221   if (!arg1) {
40222     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActorImpl & type is null", 0);
40223     return 0;
40224   }
40225   {
40226     try {
40227       result = (Dali::CustomActor *)new Dali::CustomActor(*arg1);
40228     } catch (std::out_of_range& e) {
40229       {
40230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40231       };
40232     } catch (std::exception& e) {
40233       {
40234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40235       };
40236     } catch (Dali::DaliException e) {
40237       {
40238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40239       };
40240     } catch (...) {
40241       {
40242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40243       };
40244     }
40245   }
40246
40247   jresult = (void *)result;
40248   return jresult;
40249 }
40250
40251
40252 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_2(void * jarg1) {
40253   void * jresult ;
40254   Dali::CustomActor *arg1 = 0 ;
40255   Dali::CustomActor *result = 0 ;
40256
40257   arg1 = (Dali::CustomActor *)jarg1;
40258   if (!arg1) {
40259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
40260     return 0;
40261   }
40262   {
40263     try {
40264       result = (Dali::CustomActor *)new Dali::CustomActor((Dali::CustomActor const &)*arg1);
40265     } catch (std::out_of_range& e) {
40266       {
40267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40268       };
40269     } catch (std::exception& e) {
40270       {
40271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40272       };
40273     } catch (Dali::DaliException e) {
40274       {
40275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40276       };
40277     } catch (...) {
40278       {
40279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40280       };
40281     }
40282   }
40283
40284   jresult = (void *)result;
40285   return jresult;
40286 }
40287
40288
40289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_Assign(void * jarg1, void * jarg2) {
40290   void * jresult ;
40291   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
40292   Dali::CustomActor *arg2 = 0 ;
40293   Dali::CustomActor *result = 0 ;
40294
40295   arg1 = (Dali::CustomActor *)jarg1;
40296   arg2 = (Dali::CustomActor *)jarg2;
40297   if (!arg2) {
40298     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
40299     return 0;
40300   }
40301   {
40302     try {
40303       result = (Dali::CustomActor *) &(arg1)->operator =((Dali::CustomActor const &)*arg2);
40304     } catch (std::out_of_range& e) {
40305       {
40306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40307       };
40308     } catch (std::exception& e) {
40309       {
40310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40311       };
40312     } catch (Dali::DaliException e) {
40313       {
40314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40315       };
40316     } catch (...) {
40317       {
40318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40319       };
40320     }
40321   }
40322
40323   jresult = (void *)result;
40324   return jresult;
40325 }
40326
40327
40328 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_POSITION_get() {
40329   int jresult ;
40330   int result;
40331
40332   result = (int)Dali::PanGestureDetector::Property::SCREEN_POSITION;
40333   jresult = (int)result;
40334   return jresult;
40335 }
40336
40337
40338 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_DISPLACEMENT_get() {
40339   int jresult ;
40340   int result;
40341
40342   result = (int)Dali::PanGestureDetector::Property::SCREEN_DISPLACEMENT;
40343   jresult = (int)result;
40344   return jresult;
40345 }
40346
40347
40348 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_VELOCITY_get() {
40349   int jresult ;
40350   int result;
40351
40352   result = (int)Dali::PanGestureDetector::Property::SCREEN_VELOCITY;
40353   jresult = (int)result;
40354   return jresult;
40355 }
40356
40357
40358 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_POSITION_get() {
40359   int jresult ;
40360   int result;
40361
40362   result = (int)Dali::PanGestureDetector::Property::LOCAL_POSITION;
40363   jresult = (int)result;
40364   return jresult;
40365 }
40366
40367
40368 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_DISPLACEMENT_get() {
40369   int jresult ;
40370   int result;
40371
40372   result = (int)Dali::PanGestureDetector::Property::LOCAL_DISPLACEMENT;
40373   jresult = (int)result;
40374   return jresult;
40375 }
40376
40377
40378 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_VELOCITY_get() {
40379   int jresult ;
40380   int result;
40381
40382   result = (int)Dali::PanGestureDetector::Property::LOCAL_VELOCITY;
40383   jresult = (int)result;
40384   return jresult;
40385 }
40386
40387
40388 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_PANNING_get() {
40389   int jresult ;
40390   int result;
40391
40392   result = (int)Dali::PanGestureDetector::Property::PANNING;
40393   jresult = (int)result;
40394   return jresult;
40395 }
40396
40397
40398 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector_Property() {
40399   void * jresult ;
40400   Dali::PanGestureDetector::Property *result = 0 ;
40401
40402   {
40403     try {
40404       result = (Dali::PanGestureDetector::Property *)new Dali::PanGestureDetector::Property();
40405     } catch (std::out_of_range& e) {
40406       {
40407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40408       };
40409     } catch (std::exception& e) {
40410       {
40411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40412       };
40413     } catch (Dali::DaliException e) {
40414       {
40415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40416       };
40417     } catch (...) {
40418       {
40419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40420       };
40421     }
40422   }
40423
40424   jresult = (void *)result;
40425   return jresult;
40426 }
40427
40428
40429 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector_Property(void * jarg1) {
40430   Dali::PanGestureDetector::Property *arg1 = (Dali::PanGestureDetector::Property *) 0 ;
40431
40432   arg1 = (Dali::PanGestureDetector::Property *)jarg1;
40433   {
40434     try {
40435       delete arg1;
40436     } catch (std::out_of_range& e) {
40437       {
40438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40439       };
40440     } catch (std::exception& e) {
40441       {
40442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40443       };
40444     } catch (Dali::DaliException e) {
40445       {
40446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40447       };
40448     } catch (...) {
40449       {
40450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40451       };
40452     }
40453   }
40454
40455 }
40456
40457
40458 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_LEFT_get() {
40459   void * jresult ;
40460   Dali::Radian *result = 0 ;
40461
40462   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_LEFT;
40463   jresult = (void *)result;
40464   return jresult;
40465 }
40466
40467
40468 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_RIGHT_get() {
40469   void * jresult ;
40470   Dali::Radian *result = 0 ;
40471
40472   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_RIGHT;
40473   jresult = (void *)result;
40474   return jresult;
40475 }
40476
40477
40478 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_UP_get() {
40479   void * jresult ;
40480   Dali::Radian *result = 0 ;
40481
40482   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_UP;
40483   jresult = (void *)result;
40484   return jresult;
40485 }
40486
40487
40488 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_DOWN_get() {
40489   void * jresult ;
40490   Dali::Radian *result = 0 ;
40491
40492   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_DOWN;
40493   jresult = (void *)result;
40494   return jresult;
40495 }
40496
40497
40498 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_HORIZONTAL_get() {
40499   void * jresult ;
40500   Dali::Radian *result = 0 ;
40501
40502   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_HORIZONTAL;
40503   jresult = (void *)result;
40504   return jresult;
40505 }
40506
40507
40508 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_VERTICAL_get() {
40509   void * jresult ;
40510   Dali::Radian *result = 0 ;
40511
40512   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_VERTICAL;
40513   jresult = (void *)result;
40514   return jresult;
40515 }
40516
40517
40518 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DEFAULT_THRESHOLD_get() {
40519   void * jresult ;
40520   Dali::Radian *result = 0 ;
40521
40522   result = (Dali::Radian *)&Dali::PanGestureDetector::DEFAULT_THRESHOLD;
40523   jresult = (void *)result;
40524   return jresult;
40525 }
40526
40527
40528 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_0() {
40529   void * jresult ;
40530   Dali::PanGestureDetector *result = 0 ;
40531
40532   {
40533     try {
40534       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector();
40535     } catch (std::out_of_range& e) {
40536       {
40537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40538       };
40539     } catch (std::exception& e) {
40540       {
40541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40542       };
40543     } catch (Dali::DaliException e) {
40544       {
40545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40546       };
40547     } catch (...) {
40548       {
40549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40550       };
40551     }
40552   }
40553
40554   jresult = (void *)result;
40555   return jresult;
40556 }
40557
40558
40559 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_New() {
40560   void * jresult ;
40561   Dali::PanGestureDetector result;
40562
40563   {
40564     try {
40565       result = Dali::PanGestureDetector::New();
40566     } catch (std::out_of_range& e) {
40567       {
40568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40569       };
40570     } catch (std::exception& e) {
40571       {
40572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40573       };
40574     } catch (Dali::DaliException e) {
40575       {
40576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40577       };
40578     } catch (...) {
40579       {
40580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40581       };
40582     }
40583   }
40584
40585   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
40586   return jresult;
40587 }
40588
40589
40590 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DownCast(void * jarg1) {
40591   void * jresult ;
40592   Dali::BaseHandle arg1 ;
40593   Dali::BaseHandle *argp1 ;
40594   Dali::PanGestureDetector result;
40595
40596   argp1 = (Dali::BaseHandle *)jarg1;
40597   if (!argp1) {
40598     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40599     return 0;
40600   }
40601   arg1 = *argp1;
40602   {
40603     try {
40604       result = Dali::PanGestureDetector::DownCast(arg1);
40605     } catch (std::out_of_range& e) {
40606       {
40607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40608       };
40609     } catch (std::exception& e) {
40610       {
40611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40612       };
40613     } catch (Dali::DaliException e) {
40614       {
40615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40616       };
40617     } catch (...) {
40618       {
40619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40620       };
40621     }
40622   }
40623
40624   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
40625   return jresult;
40626 }
40627
40628
40629 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector(void * jarg1) {
40630   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40631
40632   arg1 = (Dali::PanGestureDetector *)jarg1;
40633   {
40634     try {
40635       delete arg1;
40636     } catch (std::out_of_range& e) {
40637       {
40638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40639       };
40640     } catch (std::exception& e) {
40641       {
40642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40643       };
40644     } catch (Dali::DaliException e) {
40645       {
40646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40647       };
40648     } catch (...) {
40649       {
40650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40651       };
40652     }
40653   }
40654
40655 }
40656
40657
40658 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_1(void * jarg1) {
40659   void * jresult ;
40660   Dali::PanGestureDetector *arg1 = 0 ;
40661   Dali::PanGestureDetector *result = 0 ;
40662
40663   arg1 = (Dali::PanGestureDetector *)jarg1;
40664   if (!arg1) {
40665     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
40666     return 0;
40667   }
40668   {
40669     try {
40670       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector((Dali::PanGestureDetector const &)*arg1);
40671     } catch (std::out_of_range& e) {
40672       {
40673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40674       };
40675     } catch (std::exception& e) {
40676       {
40677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40678       };
40679     } catch (Dali::DaliException e) {
40680       {
40681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40682       };
40683     } catch (...) {
40684       {
40685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40686       };
40687     }
40688   }
40689
40690   jresult = (void *)result;
40691   return jresult;
40692 }
40693
40694
40695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_Assign(void * jarg1, void * jarg2) {
40696   void * jresult ;
40697   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40698   Dali::PanGestureDetector *arg2 = 0 ;
40699   Dali::PanGestureDetector *result = 0 ;
40700
40701   arg1 = (Dali::PanGestureDetector *)jarg1;
40702   arg2 = (Dali::PanGestureDetector *)jarg2;
40703   if (!arg2) {
40704     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
40705     return 0;
40706   }
40707   {
40708     try {
40709       result = (Dali::PanGestureDetector *) &(arg1)->operator =((Dali::PanGestureDetector const &)*arg2);
40710     } catch (std::out_of_range& e) {
40711       {
40712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40713       };
40714     } catch (std::exception& e) {
40715       {
40716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40717       };
40718     } catch (Dali::DaliException e) {
40719       {
40720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40721       };
40722     } catch (...) {
40723       {
40724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40725       };
40726     }
40727   }
40728
40729   jresult = (void *)result;
40730   return jresult;
40731 }
40732
40733
40734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMinimumTouchesRequired(void * jarg1, unsigned int jarg2) {
40735   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40736   unsigned int arg2 ;
40737
40738   arg1 = (Dali::PanGestureDetector *)jarg1;
40739   arg2 = (unsigned int)jarg2;
40740   {
40741     try {
40742       (arg1)->SetMinimumTouchesRequired(arg2);
40743     } catch (std::out_of_range& e) {
40744       {
40745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40746       };
40747     } catch (std::exception& e) {
40748       {
40749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40750       };
40751     } catch (Dali::DaliException e) {
40752       {
40753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40754       };
40755     } catch (...) {
40756       {
40757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40758       };
40759     }
40760   }
40761
40762 }
40763
40764
40765 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMaximumTouchesRequired(void * jarg1, unsigned int jarg2) {
40766   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40767   unsigned int arg2 ;
40768
40769   arg1 = (Dali::PanGestureDetector *)jarg1;
40770   arg2 = (unsigned int)jarg2;
40771   {
40772     try {
40773       (arg1)->SetMaximumTouchesRequired(arg2);
40774     } catch (std::out_of_range& e) {
40775       {
40776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40777       };
40778     } catch (std::exception& e) {
40779       {
40780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40781       };
40782     } catch (Dali::DaliException e) {
40783       {
40784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40785       };
40786     } catch (...) {
40787       {
40788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40789       };
40790     }
40791   }
40792
40793 }
40794
40795
40796 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
40797   unsigned int jresult ;
40798   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40799   unsigned int result;
40800
40801   arg1 = (Dali::PanGestureDetector *)jarg1;
40802   {
40803     try {
40804       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMinimumTouchesRequired();
40805     } catch (std::out_of_range& e) {
40806       {
40807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40808       };
40809     } catch (std::exception& e) {
40810       {
40811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40812       };
40813     } catch (Dali::DaliException e) {
40814       {
40815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40816       };
40817     } catch (...) {
40818       {
40819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40820       };
40821     }
40822   }
40823
40824   jresult = result;
40825   return jresult;
40826 }
40827
40828
40829 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
40830   unsigned int jresult ;
40831   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40832   unsigned int result;
40833
40834   arg1 = (Dali::PanGestureDetector *)jarg1;
40835   {
40836     try {
40837       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMaximumTouchesRequired();
40838     } catch (std::out_of_range& e) {
40839       {
40840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40841       };
40842     } catch (std::exception& e) {
40843       {
40844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40845       };
40846     } catch (Dali::DaliException e) {
40847       {
40848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40849       };
40850     } catch (...) {
40851       {
40852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40853       };
40854     }
40855   }
40856
40857   jresult = result;
40858   return jresult;
40859 }
40860
40861
40862 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
40863   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40864   Dali::Radian arg2 ;
40865   Dali::Radian arg3 ;
40866   Dali::Radian *argp2 ;
40867   Dali::Radian *argp3 ;
40868
40869   arg1 = (Dali::PanGestureDetector *)jarg1;
40870   argp2 = (Dali::Radian *)jarg2;
40871   if (!argp2) {
40872     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40873     return ;
40874   }
40875   arg2 = *argp2;
40876   argp3 = (Dali::Radian *)jarg3;
40877   if (!argp3) {
40878     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40879     return ;
40880   }
40881   arg3 = *argp3;
40882   {
40883     try {
40884       (arg1)->AddAngle(arg2,arg3);
40885     } catch (std::out_of_range& e) {
40886       {
40887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40888       };
40889     } catch (std::exception& e) {
40890       {
40891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40892       };
40893     } catch (Dali::DaliException e) {
40894       {
40895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40896       };
40897     } catch (...) {
40898       {
40899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40900       };
40901     }
40902   }
40903
40904 }
40905
40906
40907 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_1(void * jarg1, void * jarg2) {
40908   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40909   Dali::Radian arg2 ;
40910   Dali::Radian *argp2 ;
40911
40912   arg1 = (Dali::PanGestureDetector *)jarg1;
40913   argp2 = (Dali::Radian *)jarg2;
40914   if (!argp2) {
40915     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40916     return ;
40917   }
40918   arg2 = *argp2;
40919   {
40920     try {
40921       (arg1)->AddAngle(arg2);
40922     } catch (std::out_of_range& e) {
40923       {
40924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40925       };
40926     } catch (std::exception& e) {
40927       {
40928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40929       };
40930     } catch (Dali::DaliException e) {
40931       {
40932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40933       };
40934     } catch (...) {
40935       {
40936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40937       };
40938     }
40939   }
40940
40941 }
40942
40943
40944 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
40945   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40946   Dali::Radian arg2 ;
40947   Dali::Radian arg3 ;
40948   Dali::Radian *argp2 ;
40949   Dali::Radian *argp3 ;
40950
40951   arg1 = (Dali::PanGestureDetector *)jarg1;
40952   argp2 = (Dali::Radian *)jarg2;
40953   if (!argp2) {
40954     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40955     return ;
40956   }
40957   arg2 = *argp2;
40958   argp3 = (Dali::Radian *)jarg3;
40959   if (!argp3) {
40960     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40961     return ;
40962   }
40963   arg3 = *argp3;
40964   {
40965     try {
40966       (arg1)->AddDirection(arg2,arg3);
40967     } catch (std::out_of_range& e) {
40968       {
40969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40970       };
40971     } catch (std::exception& e) {
40972       {
40973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40974       };
40975     } catch (Dali::DaliException e) {
40976       {
40977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40978       };
40979     } catch (...) {
40980       {
40981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40982       };
40983     }
40984   }
40985
40986 }
40987
40988
40989 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_1(void * jarg1, void * jarg2) {
40990   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40991   Dali::Radian arg2 ;
40992   Dali::Radian *argp2 ;
40993
40994   arg1 = (Dali::PanGestureDetector *)jarg1;
40995   argp2 = (Dali::Radian *)jarg2;
40996   if (!argp2) {
40997     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40998     return ;
40999   }
41000   arg2 = *argp2;
41001   {
41002     try {
41003       (arg1)->AddDirection(arg2);
41004     } catch (std::out_of_range& e) {
41005       {
41006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41007       };
41008     } catch (std::exception& e) {
41009       {
41010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41011       };
41012     } catch (Dali::DaliException e) {
41013       {
41014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41015       };
41016     } catch (...) {
41017       {
41018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41019       };
41020     }
41021   }
41022
41023 }
41024
41025
41026 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngleCount(void * jarg1) {
41027   unsigned long jresult ;
41028   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41029   size_t result;
41030
41031   arg1 = (Dali::PanGestureDetector *)jarg1;
41032   {
41033     try {
41034       result = ((Dali::PanGestureDetector const *)arg1)->GetAngleCount();
41035     } catch (std::out_of_range& e) {
41036       {
41037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41038       };
41039     } catch (std::exception& e) {
41040       {
41041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41042       };
41043     } catch (Dali::DaliException e) {
41044       {
41045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41046       };
41047     } catch (...) {
41048       {
41049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41050       };
41051     }
41052   }
41053
41054   jresult = (unsigned long)result;
41055   return jresult;
41056 }
41057
41058
41059 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngle(void * jarg1, unsigned long jarg2) {
41060   void * jresult ;
41061   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41062   size_t arg2 ;
41063   Dali::PanGestureDetector::AngleThresholdPair result;
41064
41065   arg1 = (Dali::PanGestureDetector *)jarg1;
41066   arg2 = (size_t)jarg2;
41067   {
41068     try {
41069       result = ((Dali::PanGestureDetector const *)arg1)->GetAngle(arg2);
41070     } catch (std::out_of_range& e) {
41071       {
41072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41073       };
41074     } catch (std::exception& e) {
41075       {
41076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41077       };
41078     } catch (Dali::DaliException e) {
41079       {
41080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41081       };
41082     } catch (...) {
41083       {
41084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41085       };
41086     }
41087   }
41088
41089   jresult = new Dali::PanGestureDetector::AngleThresholdPair((const Dali::PanGestureDetector::AngleThresholdPair &)result);
41090   return jresult;
41091 }
41092
41093
41094 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_ClearAngles(void * jarg1) {
41095   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41096
41097   arg1 = (Dali::PanGestureDetector *)jarg1;
41098   {
41099     try {
41100       (arg1)->ClearAngles();
41101     } catch (std::out_of_range& e) {
41102       {
41103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41104       };
41105     } catch (std::exception& e) {
41106       {
41107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41108       };
41109     } catch (Dali::DaliException e) {
41110       {
41111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41112       };
41113     } catch (...) {
41114       {
41115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41116       };
41117     }
41118   }
41119
41120 }
41121
41122
41123 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveAngle(void * jarg1, void * jarg2) {
41124   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41125   Dali::Radian arg2 ;
41126   Dali::Radian *argp2 ;
41127
41128   arg1 = (Dali::PanGestureDetector *)jarg1;
41129   argp2 = (Dali::Radian *)jarg2;
41130   if (!argp2) {
41131     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41132     return ;
41133   }
41134   arg2 = *argp2;
41135   {
41136     try {
41137       (arg1)->RemoveAngle(arg2);
41138     } catch (std::out_of_range& e) {
41139       {
41140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41141       };
41142     } catch (std::exception& e) {
41143       {
41144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41145       };
41146     } catch (Dali::DaliException e) {
41147       {
41148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41149       };
41150     } catch (...) {
41151       {
41152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41153       };
41154     }
41155   }
41156
41157 }
41158
41159
41160 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveDirection(void * jarg1, void * jarg2) {
41161   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41162   Dali::Radian arg2 ;
41163   Dali::Radian *argp2 ;
41164
41165   arg1 = (Dali::PanGestureDetector *)jarg1;
41166   argp2 = (Dali::Radian *)jarg2;
41167   if (!argp2) {
41168     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41169     return ;
41170   }
41171   arg2 = *argp2;
41172   {
41173     try {
41174       (arg1)->RemoveDirection(arg2);
41175     } catch (std::out_of_range& e) {
41176       {
41177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41178       };
41179     } catch (std::exception& e) {
41180       {
41181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41182       };
41183     } catch (Dali::DaliException e) {
41184       {
41185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41186       };
41187     } catch (...) {
41188       {
41189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41190       };
41191     }
41192   }
41193
41194 }
41195
41196
41197 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DetectedSignal(void * jarg1) {
41198   void * jresult ;
41199   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41200   Dali::PanGestureDetector::DetectedSignalType *result = 0 ;
41201
41202   arg1 = (Dali::PanGestureDetector *)jarg1;
41203   {
41204     try {
41205       result = (Dali::PanGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
41206     } catch (std::out_of_range& e) {
41207       {
41208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41209       };
41210     } catch (std::exception& e) {
41211       {
41212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41213       };
41214     } catch (Dali::DaliException e) {
41215       {
41216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41217       };
41218     } catch (...) {
41219       {
41220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41221       };
41222     }
41223   }
41224
41225   jresult = (void *)result;
41226   return jresult;
41227 }
41228
41229
41230 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetPanGestureProperties(void * jarg1) {
41231   Dali::PanGesture *arg1 = 0 ;
41232
41233   arg1 = (Dali::PanGesture *)jarg1;
41234   if (!arg1) {
41235     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
41236     return ;
41237   }
41238   {
41239     try {
41240       Dali::PanGestureDetector::SetPanGestureProperties((Dali::PanGesture const &)*arg1);
41241     } catch (std::out_of_range& e) {
41242       {
41243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41244       };
41245     } catch (std::exception& e) {
41246       {
41247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41248       };
41249     } catch (Dali::DaliException e) {
41250       {
41251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41252       };
41253     } catch (...) {
41254       {
41255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41256       };
41257     }
41258   }
41259
41260 }
41261
41262
41263 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_0() {
41264   void * jresult ;
41265   Dali::PanGesture *result = 0 ;
41266
41267   {
41268     try {
41269       result = (Dali::PanGesture *)new Dali::PanGesture();
41270     } catch (std::out_of_range& e) {
41271       {
41272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41273       };
41274     } catch (std::exception& e) {
41275       {
41276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41277       };
41278     } catch (Dali::DaliException e) {
41279       {
41280         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41281       };
41282     } catch (...) {
41283       {
41284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41285       };
41286     }
41287   }
41288
41289   jresult = (void *)result;
41290   return jresult;
41291 }
41292
41293
41294 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_1(int jarg1) {
41295   void * jresult ;
41296   Dali::Gesture::State arg1 ;
41297   Dali::PanGesture *result = 0 ;
41298
41299   arg1 = (Dali::Gesture::State)jarg1;
41300   {
41301     try {
41302       result = (Dali::PanGesture *)new Dali::PanGesture(arg1);
41303     } catch (std::out_of_range& e) {
41304       {
41305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41306       };
41307     } catch (std::exception& e) {
41308       {
41309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41310       };
41311     } catch (Dali::DaliException e) {
41312       {
41313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41314       };
41315     } catch (...) {
41316       {
41317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41318       };
41319     }
41320   }
41321
41322   jresult = (void *)result;
41323   return jresult;
41324 }
41325
41326
41327 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_2(void * jarg1) {
41328   void * jresult ;
41329   Dali::PanGesture *arg1 = 0 ;
41330   Dali::PanGesture *result = 0 ;
41331
41332   arg1 = (Dali::PanGesture *)jarg1;
41333   if (!arg1) {
41334     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
41335     return 0;
41336   }
41337   {
41338     try {
41339       result = (Dali::PanGesture *)new Dali::PanGesture((Dali::PanGesture const &)*arg1);
41340     } catch (std::out_of_range& e) {
41341       {
41342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41343       };
41344     } catch (std::exception& e) {
41345       {
41346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41347       };
41348     } catch (Dali::DaliException e) {
41349       {
41350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41351       };
41352     } catch (...) {
41353       {
41354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41355       };
41356     }
41357   }
41358
41359   jresult = (void *)result;
41360   return jresult;
41361 }
41362
41363
41364 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_Assign(void * jarg1, void * jarg2) {
41365   void * jresult ;
41366   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41367   Dali::PanGesture *arg2 = 0 ;
41368   Dali::PanGesture *result = 0 ;
41369
41370   arg1 = (Dali::PanGesture *)jarg1;
41371   arg2 = (Dali::PanGesture *)jarg2;
41372   if (!arg2) {
41373     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
41374     return 0;
41375   }
41376   {
41377     try {
41378       result = (Dali::PanGesture *) &(arg1)->operator =((Dali::PanGesture const &)*arg2);
41379     } catch (std::out_of_range& e) {
41380       {
41381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41382       };
41383     } catch (std::exception& e) {
41384       {
41385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41386       };
41387     } catch (Dali::DaliException e) {
41388       {
41389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41390       };
41391     } catch (...) {
41392       {
41393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41394       };
41395     }
41396   }
41397
41398   jresult = (void *)result;
41399   return jresult;
41400 }
41401
41402
41403 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGesture(void * jarg1) {
41404   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41405
41406   arg1 = (Dali::PanGesture *)jarg1;
41407   {
41408     try {
41409       delete arg1;
41410     } catch (std::out_of_range& e) {
41411       {
41412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41413       };
41414     } catch (std::exception& e) {
41415       {
41416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41417       };
41418     } catch (Dali::DaliException e) {
41419       {
41420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41421       };
41422     } catch (...) {
41423       {
41424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41425       };
41426     }
41427   }
41428
41429 }
41430
41431
41432 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_velocity_set(void * jarg1, void * jarg2) {
41433   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41434   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41435
41436   arg1 = (Dali::PanGesture *)jarg1;
41437   arg2 = (Dali::Vector2 *)jarg2;
41438   if (arg1) (arg1)->velocity = *arg2;
41439 }
41440
41441
41442 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_velocity_get(void * jarg1) {
41443   void * jresult ;
41444   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41445   Dali::Vector2 *result = 0 ;
41446
41447   arg1 = (Dali::PanGesture *)jarg1;
41448   result = (Dali::Vector2 *)& ((arg1)->velocity);
41449   jresult = (void *)result;
41450   return jresult;
41451 }
41452
41453
41454 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_displacement_set(void * jarg1, void * jarg2) {
41455   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41456   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41457
41458   arg1 = (Dali::PanGesture *)jarg1;
41459   arg2 = (Dali::Vector2 *)jarg2;
41460   if (arg1) (arg1)->displacement = *arg2;
41461 }
41462
41463
41464 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_displacement_get(void * jarg1) {
41465   void * jresult ;
41466   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41467   Dali::Vector2 *result = 0 ;
41468
41469   arg1 = (Dali::PanGesture *)jarg1;
41470   result = (Dali::Vector2 *)& ((arg1)->displacement);
41471   jresult = (void *)result;
41472   return jresult;
41473 }
41474
41475
41476 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_position_set(void * jarg1, void * jarg2) {
41477   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41478   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41479
41480   arg1 = (Dali::PanGesture *)jarg1;
41481   arg2 = (Dali::Vector2 *)jarg2;
41482   if (arg1) (arg1)->position = *arg2;
41483 }
41484
41485
41486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_position_get(void * jarg1) {
41487   void * jresult ;
41488   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41489   Dali::Vector2 *result = 0 ;
41490
41491   arg1 = (Dali::PanGesture *)jarg1;
41492   result = (Dali::Vector2 *)& ((arg1)->position);
41493   jresult = (void *)result;
41494   return jresult;
41495 }
41496
41497
41498 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_set(void * jarg1, void * jarg2) {
41499   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41500   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41501
41502   arg1 = (Dali::PanGesture *)jarg1;
41503   arg2 = (Dali::Vector2 *)jarg2;
41504   if (arg1) (arg1)->screenVelocity = *arg2;
41505 }
41506
41507
41508 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_get(void * jarg1) {
41509   void * jresult ;
41510   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41511   Dali::Vector2 *result = 0 ;
41512
41513   arg1 = (Dali::PanGesture *)jarg1;
41514   result = (Dali::Vector2 *)& ((arg1)->screenVelocity);
41515   jresult = (void *)result;
41516   return jresult;
41517 }
41518
41519
41520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_set(void * jarg1, void * jarg2) {
41521   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41522   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41523
41524   arg1 = (Dali::PanGesture *)jarg1;
41525   arg2 = (Dali::Vector2 *)jarg2;
41526   if (arg1) (arg1)->screenDisplacement = *arg2;
41527 }
41528
41529
41530 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_get(void * jarg1) {
41531   void * jresult ;
41532   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41533   Dali::Vector2 *result = 0 ;
41534
41535   arg1 = (Dali::PanGesture *)jarg1;
41536   result = (Dali::Vector2 *)& ((arg1)->screenDisplacement);
41537   jresult = (void *)result;
41538   return jresult;
41539 }
41540
41541
41542 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_set(void * jarg1, void * jarg2) {
41543   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41544   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41545
41546   arg1 = (Dali::PanGesture *)jarg1;
41547   arg2 = (Dali::Vector2 *)jarg2;
41548   if (arg1) (arg1)->screenPosition = *arg2;
41549 }
41550
41551
41552 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_get(void * jarg1) {
41553   void * jresult ;
41554   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41555   Dali::Vector2 *result = 0 ;
41556
41557   arg1 = (Dali::PanGesture *)jarg1;
41558   result = (Dali::Vector2 *)& ((arg1)->screenPosition);
41559   jresult = (void *)result;
41560   return jresult;
41561 }
41562
41563
41564 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
41565   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41566   unsigned int arg2 ;
41567
41568   arg1 = (Dali::PanGesture *)jarg1;
41569   arg2 = (unsigned int)jarg2;
41570   if (arg1) (arg1)->numberOfTouches = arg2;
41571 }
41572
41573
41574 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_get(void * jarg1) {
41575   unsigned int jresult ;
41576   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41577   unsigned int result;
41578
41579   arg1 = (Dali::PanGesture *)jarg1;
41580   result = (unsigned int) ((arg1)->numberOfTouches);
41581   jresult = result;
41582   return jresult;
41583 }
41584
41585
41586 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetSpeed(void * jarg1) {
41587   float jresult ;
41588   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41589   float result;
41590
41591   arg1 = (Dali::PanGesture *)jarg1;
41592   {
41593     try {
41594       result = (float)((Dali::PanGesture const *)arg1)->GetSpeed();
41595     } catch (std::out_of_range& e) {
41596       {
41597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41598       };
41599     } catch (std::exception& e) {
41600       {
41601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41602       };
41603     } catch (Dali::DaliException e) {
41604       {
41605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41606       };
41607     } catch (...) {
41608       {
41609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41610       };
41611     }
41612   }
41613
41614   jresult = result;
41615   return jresult;
41616 }
41617
41618
41619 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetDistance(void * jarg1) {
41620   float jresult ;
41621   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41622   float result;
41623
41624   arg1 = (Dali::PanGesture *)jarg1;
41625   {
41626     try {
41627       result = (float)((Dali::PanGesture const *)arg1)->GetDistance();
41628     } catch (std::out_of_range& e) {
41629       {
41630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41631       };
41632     } catch (std::exception& e) {
41633       {
41634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41635       };
41636     } catch (Dali::DaliException e) {
41637       {
41638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41639       };
41640     } catch (...) {
41641       {
41642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41643       };
41644     }
41645   }
41646
41647   jresult = result;
41648   return jresult;
41649 }
41650
41651
41652 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenSpeed(void * jarg1) {
41653   float jresult ;
41654   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41655   float result;
41656
41657   arg1 = (Dali::PanGesture *)jarg1;
41658   {
41659     try {
41660       result = (float)((Dali::PanGesture const *)arg1)->GetScreenSpeed();
41661     } catch (std::out_of_range& e) {
41662       {
41663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41664       };
41665     } catch (std::exception& e) {
41666       {
41667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41668       };
41669     } catch (Dali::DaliException e) {
41670       {
41671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41672       };
41673     } catch (...) {
41674       {
41675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41676       };
41677     }
41678   }
41679
41680   jresult = result;
41681   return jresult;
41682 }
41683
41684
41685 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenDistance(void * jarg1) {
41686   float jresult ;
41687   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41688   float result;
41689
41690   arg1 = (Dali::PanGesture *)jarg1;
41691   {
41692     try {
41693       result = (float)((Dali::PanGesture const *)arg1)->GetScreenDistance();
41694     } catch (std::out_of_range& e) {
41695       {
41696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41697       };
41698     } catch (std::exception& e) {
41699       {
41700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41701       };
41702     } catch (Dali::DaliException e) {
41703       {
41704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41705       };
41706     } catch (...) {
41707       {
41708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41709       };
41710     }
41711   }
41712
41713   jresult = result;
41714   return jresult;
41715 }
41716
41717
41718 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_0() {
41719   void * jresult ;
41720   Dali::PinchGestureDetector *result = 0 ;
41721
41722   {
41723     try {
41724       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector();
41725     } catch (std::out_of_range& e) {
41726       {
41727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41728       };
41729     } catch (std::exception& e) {
41730       {
41731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41732       };
41733     } catch (Dali::DaliException e) {
41734       {
41735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41736       };
41737     } catch (...) {
41738       {
41739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41740       };
41741     }
41742   }
41743
41744   jresult = (void *)result;
41745   return jresult;
41746 }
41747
41748
41749 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_New() {
41750   void * jresult ;
41751   Dali::PinchGestureDetector result;
41752
41753   {
41754     try {
41755       result = Dali::PinchGestureDetector::New();
41756     } catch (std::out_of_range& e) {
41757       {
41758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41759       };
41760     } catch (std::exception& e) {
41761       {
41762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41763       };
41764     } catch (Dali::DaliException e) {
41765       {
41766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41767       };
41768     } catch (...) {
41769       {
41770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41771       };
41772     }
41773   }
41774
41775   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
41776   return jresult;
41777 }
41778
41779
41780 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DownCast(void * jarg1) {
41781   void * jresult ;
41782   Dali::BaseHandle arg1 ;
41783   Dali::BaseHandle *argp1 ;
41784   Dali::PinchGestureDetector result;
41785
41786   argp1 = (Dali::BaseHandle *)jarg1;
41787   if (!argp1) {
41788     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41789     return 0;
41790   }
41791   arg1 = *argp1;
41792   {
41793     try {
41794       result = Dali::PinchGestureDetector::DownCast(arg1);
41795     } catch (std::out_of_range& e) {
41796       {
41797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41798       };
41799     } catch (std::exception& e) {
41800       {
41801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41802       };
41803     } catch (Dali::DaliException e) {
41804       {
41805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41806       };
41807     } catch (...) {
41808       {
41809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41810       };
41811     }
41812   }
41813
41814   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
41815   return jresult;
41816 }
41817
41818
41819 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetector(void * jarg1) {
41820   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41821
41822   arg1 = (Dali::PinchGestureDetector *)jarg1;
41823   {
41824     try {
41825       delete arg1;
41826     } catch (std::out_of_range& e) {
41827       {
41828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41829       };
41830     } catch (std::exception& e) {
41831       {
41832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41833       };
41834     } catch (Dali::DaliException e) {
41835       {
41836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41837       };
41838     } catch (...) {
41839       {
41840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41841       };
41842     }
41843   }
41844
41845 }
41846
41847
41848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_1(void * jarg1) {
41849   void * jresult ;
41850   Dali::PinchGestureDetector *arg1 = 0 ;
41851   Dali::PinchGestureDetector *result = 0 ;
41852
41853   arg1 = (Dali::PinchGestureDetector *)jarg1;
41854   if (!arg1) {
41855     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
41856     return 0;
41857   }
41858   {
41859     try {
41860       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector((Dali::PinchGestureDetector const &)*arg1);
41861     } catch (std::out_of_range& e) {
41862       {
41863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41864       };
41865     } catch (std::exception& e) {
41866       {
41867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41868       };
41869     } catch (Dali::DaliException e) {
41870       {
41871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41872       };
41873     } catch (...) {
41874       {
41875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41876       };
41877     }
41878   }
41879
41880   jresult = (void *)result;
41881   return jresult;
41882 }
41883
41884
41885 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_Assign(void * jarg1, void * jarg2) {
41886   void * jresult ;
41887   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41888   Dali::PinchGestureDetector *arg2 = 0 ;
41889   Dali::PinchGestureDetector *result = 0 ;
41890
41891   arg1 = (Dali::PinchGestureDetector *)jarg1;
41892   arg2 = (Dali::PinchGestureDetector *)jarg2;
41893   if (!arg2) {
41894     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
41895     return 0;
41896   }
41897   {
41898     try {
41899       result = (Dali::PinchGestureDetector *) &(arg1)->operator =((Dali::PinchGestureDetector const &)*arg2);
41900     } catch (std::out_of_range& e) {
41901       {
41902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41903       };
41904     } catch (std::exception& e) {
41905       {
41906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41907       };
41908     } catch (Dali::DaliException e) {
41909       {
41910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41911       };
41912     } catch (...) {
41913       {
41914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41915       };
41916     }
41917   }
41918
41919   jresult = (void *)result;
41920   return jresult;
41921 }
41922
41923
41924 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DetectedSignal(void * jarg1) {
41925   void * jresult ;
41926   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41927   Dali::PinchGestureDetector::DetectedSignalType *result = 0 ;
41928
41929   arg1 = (Dali::PinchGestureDetector *)jarg1;
41930   {
41931     try {
41932       result = (Dali::PinchGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
41933     } catch (std::out_of_range& e) {
41934       {
41935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41936       };
41937     } catch (std::exception& e) {
41938       {
41939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41940       };
41941     } catch (Dali::DaliException e) {
41942       {
41943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41944       };
41945     } catch (...) {
41946       {
41947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41948       };
41949     }
41950   }
41951
41952   jresult = (void *)result;
41953   return jresult;
41954 }
41955
41956
41957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_0(int jarg1) {
41958   void * jresult ;
41959   Dali::Gesture::State arg1 ;
41960   Dali::PinchGesture *result = 0 ;
41961
41962   arg1 = (Dali::Gesture::State)jarg1;
41963   {
41964     try {
41965       result = (Dali::PinchGesture *)new Dali::PinchGesture(arg1);
41966     } catch (std::out_of_range& e) {
41967       {
41968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41969       };
41970     } catch (std::exception& e) {
41971       {
41972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41973       };
41974     } catch (Dali::DaliException e) {
41975       {
41976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41977       };
41978     } catch (...) {
41979       {
41980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41981       };
41982     }
41983   }
41984
41985   jresult = (void *)result;
41986   return jresult;
41987 }
41988
41989
41990 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_1(void * jarg1) {
41991   void * jresult ;
41992   Dali::PinchGesture *arg1 = 0 ;
41993   Dali::PinchGesture *result = 0 ;
41994
41995   arg1 = (Dali::PinchGesture *)jarg1;
41996   if (!arg1) {
41997     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
41998     return 0;
41999   }
42000   {
42001     try {
42002       result = (Dali::PinchGesture *)new Dali::PinchGesture((Dali::PinchGesture const &)*arg1);
42003     } catch (std::out_of_range& e) {
42004       {
42005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42006       };
42007     } catch (std::exception& e) {
42008       {
42009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42010       };
42011     } catch (Dali::DaliException e) {
42012       {
42013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42014       };
42015     } catch (...) {
42016       {
42017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42018       };
42019     }
42020   }
42021
42022   jresult = (void *)result;
42023   return jresult;
42024 }
42025
42026
42027 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_Assign(void * jarg1, void * jarg2) {
42028   void * jresult ;
42029   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42030   Dali::PinchGesture *arg2 = 0 ;
42031   Dali::PinchGesture *result = 0 ;
42032
42033   arg1 = (Dali::PinchGesture *)jarg1;
42034   arg2 = (Dali::PinchGesture *)jarg2;
42035   if (!arg2) {
42036     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
42037     return 0;
42038   }
42039   {
42040     try {
42041       result = (Dali::PinchGesture *) &(arg1)->operator =((Dali::PinchGesture const &)*arg2);
42042     } catch (std::out_of_range& e) {
42043       {
42044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42045       };
42046     } catch (std::exception& e) {
42047       {
42048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42049       };
42050     } catch (Dali::DaliException e) {
42051       {
42052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42053       };
42054     } catch (...) {
42055       {
42056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42057       };
42058     }
42059   }
42060
42061   jresult = (void *)result;
42062   return jresult;
42063 }
42064
42065
42066 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGesture(void * jarg1) {
42067   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42068
42069   arg1 = (Dali::PinchGesture *)jarg1;
42070   {
42071     try {
42072       delete arg1;
42073     } catch (std::out_of_range& e) {
42074       {
42075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42076       };
42077     } catch (std::exception& e) {
42078       {
42079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42080       };
42081     } catch (Dali::DaliException e) {
42082       {
42083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42084       };
42085     } catch (...) {
42086       {
42087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42088       };
42089     }
42090   }
42091
42092 }
42093
42094
42095 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_scale_set(void * jarg1, float jarg2) {
42096   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42097   float arg2 ;
42098
42099   arg1 = (Dali::PinchGesture *)jarg1;
42100   arg2 = (float)jarg2;
42101   if (arg1) (arg1)->scale = arg2;
42102 }
42103
42104
42105 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_scale_get(void * jarg1) {
42106   float jresult ;
42107   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42108   float result;
42109
42110   arg1 = (Dali::PinchGesture *)jarg1;
42111   result = (float) ((arg1)->scale);
42112   jresult = result;
42113   return jresult;
42114 }
42115
42116
42117 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_speed_set(void * jarg1, float jarg2) {
42118   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42119   float arg2 ;
42120
42121   arg1 = (Dali::PinchGesture *)jarg1;
42122   arg2 = (float)jarg2;
42123   if (arg1) (arg1)->speed = arg2;
42124 }
42125
42126
42127 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_speed_get(void * jarg1) {
42128   float jresult ;
42129   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42130   float result;
42131
42132   arg1 = (Dali::PinchGesture *)jarg1;
42133   result = (float) ((arg1)->speed);
42134   jresult = result;
42135   return jresult;
42136 }
42137
42138
42139 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_set(void * jarg1, void * jarg2) {
42140   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42141   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42142
42143   arg1 = (Dali::PinchGesture *)jarg1;
42144   arg2 = (Dali::Vector2 *)jarg2;
42145   if (arg1) (arg1)->screenCenterPoint = *arg2;
42146 }
42147
42148
42149 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_get(void * jarg1) {
42150   void * jresult ;
42151   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42152   Dali::Vector2 *result = 0 ;
42153
42154   arg1 = (Dali::PinchGesture *)jarg1;
42155   result = (Dali::Vector2 *)& ((arg1)->screenCenterPoint);
42156   jresult = (void *)result;
42157   return jresult;
42158 }
42159
42160
42161 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_set(void * jarg1, void * jarg2) {
42162   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42163   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42164
42165   arg1 = (Dali::PinchGesture *)jarg1;
42166   arg2 = (Dali::Vector2 *)jarg2;
42167   if (arg1) (arg1)->localCenterPoint = *arg2;
42168 }
42169
42170
42171 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_get(void * jarg1) {
42172   void * jresult ;
42173   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42174   Dali::Vector2 *result = 0 ;
42175
42176   arg1 = (Dali::PinchGesture *)jarg1;
42177   result = (Dali::Vector2 *)& ((arg1)->localCenterPoint);
42178   jresult = (void *)result;
42179   return jresult;
42180 }
42181
42182
42183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_0() {
42184   void * jresult ;
42185   Dali::TapGestureDetector *result = 0 ;
42186
42187   {
42188     try {
42189       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector();
42190     } catch (std::out_of_range& e) {
42191       {
42192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42193       };
42194     } catch (std::exception& e) {
42195       {
42196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42197       };
42198     } catch (Dali::DaliException e) {
42199       {
42200         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42201       };
42202     } catch (...) {
42203       {
42204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42205       };
42206     }
42207   }
42208
42209   jresult = (void *)result;
42210   return jresult;
42211 }
42212
42213
42214 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_0() {
42215   void * jresult ;
42216   Dali::TapGestureDetector result;
42217
42218   {
42219     try {
42220       result = Dali::TapGestureDetector::New();
42221     } catch (std::out_of_range& e) {
42222       {
42223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42224       };
42225     } catch (std::exception& e) {
42226       {
42227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42228       };
42229     } catch (Dali::DaliException e) {
42230       {
42231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42232       };
42233     } catch (...) {
42234       {
42235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42236       };
42237     }
42238   }
42239
42240   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
42241   return jresult;
42242 }
42243
42244
42245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_1(unsigned int jarg1) {
42246   void * jresult ;
42247   unsigned int arg1 ;
42248   Dali::TapGestureDetector result;
42249
42250   arg1 = (unsigned int)jarg1;
42251   {
42252     try {
42253       result = Dali::TapGestureDetector::New(arg1);
42254     } catch (std::out_of_range& e) {
42255       {
42256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42257       };
42258     } catch (std::exception& e) {
42259       {
42260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42261       };
42262     } catch (Dali::DaliException e) {
42263       {
42264         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42265       };
42266     } catch (...) {
42267       {
42268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42269       };
42270     }
42271   }
42272
42273   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
42274   return jresult;
42275 }
42276
42277
42278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DownCast(void * jarg1) {
42279   void * jresult ;
42280   Dali::BaseHandle arg1 ;
42281   Dali::BaseHandle *argp1 ;
42282   Dali::TapGestureDetector result;
42283
42284   argp1 = (Dali::BaseHandle *)jarg1;
42285   if (!argp1) {
42286     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42287     return 0;
42288   }
42289   arg1 = *argp1;
42290   {
42291     try {
42292       result = Dali::TapGestureDetector::DownCast(arg1);
42293     } catch (std::out_of_range& e) {
42294       {
42295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42296       };
42297     } catch (std::exception& e) {
42298       {
42299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42300       };
42301     } catch (Dali::DaliException e) {
42302       {
42303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42304       };
42305     } catch (...) {
42306       {
42307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42308       };
42309     }
42310   }
42311
42312   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
42313   return jresult;
42314 }
42315
42316
42317 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetector(void * jarg1) {
42318   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42319
42320   arg1 = (Dali::TapGestureDetector *)jarg1;
42321   {
42322     try {
42323       delete arg1;
42324     } catch (std::out_of_range& e) {
42325       {
42326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42327       };
42328     } catch (std::exception& e) {
42329       {
42330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42331       };
42332     } catch (Dali::DaliException e) {
42333       {
42334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42335       };
42336     } catch (...) {
42337       {
42338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42339       };
42340     }
42341   }
42342
42343 }
42344
42345
42346 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_1(void * jarg1) {
42347   void * jresult ;
42348   Dali::TapGestureDetector *arg1 = 0 ;
42349   Dali::TapGestureDetector *result = 0 ;
42350
42351   arg1 = (Dali::TapGestureDetector *)jarg1;
42352   if (!arg1) {
42353     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
42354     return 0;
42355   }
42356   {
42357     try {
42358       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector((Dali::TapGestureDetector const &)*arg1);
42359     } catch (std::out_of_range& e) {
42360       {
42361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42362       };
42363     } catch (std::exception& e) {
42364       {
42365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42366       };
42367     } catch (Dali::DaliException e) {
42368       {
42369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42370       };
42371     } catch (...) {
42372       {
42373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42374       };
42375     }
42376   }
42377
42378   jresult = (void *)result;
42379   return jresult;
42380 }
42381
42382
42383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_Assign(void * jarg1, void * jarg2) {
42384   void * jresult ;
42385   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42386   Dali::TapGestureDetector *arg2 = 0 ;
42387   Dali::TapGestureDetector *result = 0 ;
42388
42389   arg1 = (Dali::TapGestureDetector *)jarg1;
42390   arg2 = (Dali::TapGestureDetector *)jarg2;
42391   if (!arg2) {
42392     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
42393     return 0;
42394   }
42395   {
42396     try {
42397       result = (Dali::TapGestureDetector *) &(arg1)->operator =((Dali::TapGestureDetector const &)*arg2);
42398     } catch (std::out_of_range& e) {
42399       {
42400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42401       };
42402     } catch (std::exception& e) {
42403       {
42404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42405       };
42406     } catch (Dali::DaliException e) {
42407       {
42408         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42409       };
42410     } catch (...) {
42411       {
42412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42413       };
42414     }
42415   }
42416
42417   jresult = (void *)result;
42418   return jresult;
42419 }
42420
42421
42422 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMinimumTapsRequired(void * jarg1, unsigned int jarg2) {
42423   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42424   unsigned int arg2 ;
42425
42426   arg1 = (Dali::TapGestureDetector *)jarg1;
42427   arg2 = (unsigned int)jarg2;
42428   {
42429     try {
42430       (arg1)->SetMinimumTapsRequired(arg2);
42431     } catch (std::out_of_range& e) {
42432       {
42433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42434       };
42435     } catch (std::exception& e) {
42436       {
42437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42438       };
42439     } catch (Dali::DaliException e) {
42440       {
42441         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42442       };
42443     } catch (...) {
42444       {
42445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42446       };
42447     }
42448   }
42449
42450 }
42451
42452
42453 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMaximumTapsRequired(void * jarg1, unsigned int jarg2) {
42454   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42455   unsigned int arg2 ;
42456
42457   arg1 = (Dali::TapGestureDetector *)jarg1;
42458   arg2 = (unsigned int)jarg2;
42459   {
42460     try {
42461       (arg1)->SetMaximumTapsRequired(arg2);
42462     } catch (std::out_of_range& e) {
42463       {
42464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42465       };
42466     } catch (std::exception& e) {
42467       {
42468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42469       };
42470     } catch (Dali::DaliException e) {
42471       {
42472         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42473       };
42474     } catch (...) {
42475       {
42476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42477       };
42478     }
42479   }
42480
42481 }
42482
42483
42484 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMinimumTapsRequired(void * jarg1) {
42485   unsigned int jresult ;
42486   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42487   unsigned int result;
42488
42489   arg1 = (Dali::TapGestureDetector *)jarg1;
42490   {
42491     try {
42492       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMinimumTapsRequired();
42493     } catch (std::out_of_range& e) {
42494       {
42495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42496       };
42497     } catch (std::exception& e) {
42498       {
42499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42500       };
42501     } catch (Dali::DaliException e) {
42502       {
42503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42504       };
42505     } catch (...) {
42506       {
42507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42508       };
42509     }
42510   }
42511
42512   jresult = result;
42513   return jresult;
42514 }
42515
42516
42517 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMaximumTapsRequired(void * jarg1) {
42518   unsigned int jresult ;
42519   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42520   unsigned int result;
42521
42522   arg1 = (Dali::TapGestureDetector *)jarg1;
42523   {
42524     try {
42525       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMaximumTapsRequired();
42526     } catch (std::out_of_range& e) {
42527       {
42528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42529       };
42530     } catch (std::exception& e) {
42531       {
42532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42533       };
42534     } catch (Dali::DaliException e) {
42535       {
42536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42537       };
42538     } catch (...) {
42539       {
42540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42541       };
42542     }
42543   }
42544
42545   jresult = result;
42546   return jresult;
42547 }
42548
42549
42550 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DetectedSignal(void * jarg1) {
42551   void * jresult ;
42552   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42553   Dali::TapGestureDetector::DetectedSignalType *result = 0 ;
42554
42555   arg1 = (Dali::TapGestureDetector *)jarg1;
42556   {
42557     try {
42558       result = (Dali::TapGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
42559     } catch (std::out_of_range& e) {
42560       {
42561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42562       };
42563     } catch (std::exception& e) {
42564       {
42565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42566       };
42567     } catch (Dali::DaliException e) {
42568       {
42569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42570       };
42571     } catch (...) {
42572       {
42573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42574       };
42575     }
42576   }
42577
42578   jresult = (void *)result;
42579   return jresult;
42580 }
42581
42582
42583 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_0() {
42584   void * jresult ;
42585   Dali::TapGesture *result = 0 ;
42586
42587   {
42588     try {
42589       result = (Dali::TapGesture *)new Dali::TapGesture();
42590     } catch (std::out_of_range& e) {
42591       {
42592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42593       };
42594     } catch (std::exception& e) {
42595       {
42596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42597       };
42598     } catch (Dali::DaliException e) {
42599       {
42600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42601       };
42602     } catch (...) {
42603       {
42604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42605       };
42606     }
42607   }
42608
42609   jresult = (void *)result;
42610   return jresult;
42611 }
42612
42613
42614 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_1(void * jarg1) {
42615   void * jresult ;
42616   Dali::TapGesture *arg1 = 0 ;
42617   Dali::TapGesture *result = 0 ;
42618
42619   arg1 = (Dali::TapGesture *)jarg1;
42620   if (!arg1) {
42621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
42622     return 0;
42623   }
42624   {
42625     try {
42626       result = (Dali::TapGesture *)new Dali::TapGesture((Dali::TapGesture const &)*arg1);
42627     } catch (std::out_of_range& e) {
42628       {
42629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42630       };
42631     } catch (std::exception& e) {
42632       {
42633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42634       };
42635     } catch (Dali::DaliException e) {
42636       {
42637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42638       };
42639     } catch (...) {
42640       {
42641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42642       };
42643     }
42644   }
42645
42646   jresult = (void *)result;
42647   return jresult;
42648 }
42649
42650
42651 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_Assign(void * jarg1, void * jarg2) {
42652   void * jresult ;
42653   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42654   Dali::TapGesture *arg2 = 0 ;
42655   Dali::TapGesture *result = 0 ;
42656
42657   arg1 = (Dali::TapGesture *)jarg1;
42658   arg2 = (Dali::TapGesture *)jarg2;
42659   if (!arg2) {
42660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
42661     return 0;
42662   }
42663   {
42664     try {
42665       result = (Dali::TapGesture *) &(arg1)->operator =((Dali::TapGesture const &)*arg2);
42666     } catch (std::out_of_range& e) {
42667       {
42668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42669       };
42670     } catch (std::exception& e) {
42671       {
42672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42673       };
42674     } catch (Dali::DaliException e) {
42675       {
42676         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42677       };
42678     } catch (...) {
42679       {
42680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42681       };
42682     }
42683   }
42684
42685   jresult = (void *)result;
42686   return jresult;
42687 }
42688
42689
42690 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGesture(void * jarg1) {
42691   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42692
42693   arg1 = (Dali::TapGesture *)jarg1;
42694   {
42695     try {
42696       delete arg1;
42697     } catch (std::out_of_range& e) {
42698       {
42699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42700       };
42701     } catch (std::exception& e) {
42702       {
42703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42704       };
42705     } catch (Dali::DaliException e) {
42706       {
42707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42708       };
42709     } catch (...) {
42710       {
42711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42712       };
42713     }
42714   }
42715
42716 }
42717
42718
42719 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_set(void * jarg1, unsigned int jarg2) {
42720   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42721   unsigned int arg2 ;
42722
42723   arg1 = (Dali::TapGesture *)jarg1;
42724   arg2 = (unsigned int)jarg2;
42725   if (arg1) (arg1)->numberOfTaps = arg2;
42726 }
42727
42728
42729 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_get(void * jarg1) {
42730   unsigned int jresult ;
42731   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42732   unsigned int result;
42733
42734   arg1 = (Dali::TapGesture *)jarg1;
42735   result = (unsigned int) ((arg1)->numberOfTaps);
42736   jresult = result;
42737   return jresult;
42738 }
42739
42740
42741 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
42742   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42743   unsigned int arg2 ;
42744
42745   arg1 = (Dali::TapGesture *)jarg1;
42746   arg2 = (unsigned int)jarg2;
42747   if (arg1) (arg1)->numberOfTouches = arg2;
42748 }
42749
42750
42751 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_get(void * jarg1) {
42752   unsigned int jresult ;
42753   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42754   unsigned int result;
42755
42756   arg1 = (Dali::TapGesture *)jarg1;
42757   result = (unsigned int) ((arg1)->numberOfTouches);
42758   jresult = result;
42759   return jresult;
42760 }
42761
42762
42763 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_set(void * jarg1, void * jarg2) {
42764   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42765   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42766
42767   arg1 = (Dali::TapGesture *)jarg1;
42768   arg2 = (Dali::Vector2 *)jarg2;
42769   if (arg1) (arg1)->screenPoint = *arg2;
42770 }
42771
42772
42773 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_get(void * jarg1) {
42774   void * jresult ;
42775   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42776   Dali::Vector2 *result = 0 ;
42777
42778   arg1 = (Dali::TapGesture *)jarg1;
42779   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
42780   jresult = (void *)result;
42781   return jresult;
42782 }
42783
42784
42785 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_set(void * jarg1, void * jarg2) {
42786   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42787   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42788
42789   arg1 = (Dali::TapGesture *)jarg1;
42790   arg2 = (Dali::Vector2 *)jarg2;
42791   if (arg1) (arg1)->localPoint = *arg2;
42792 }
42793
42794
42795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_get(void * jarg1) {
42796   void * jresult ;
42797   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42798   Dali::Vector2 *result = 0 ;
42799
42800   arg1 = (Dali::TapGesture *)jarg1;
42801   result = (Dali::Vector2 *)& ((arg1)->localPoint);
42802   jresult = (void *)result;
42803   return jresult;
42804 }
42805
42806
42807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_0() {
42808   void * jresult ;
42809   Dali::AlphaFunction *result = 0 ;
42810
42811   {
42812     try {
42813       result = (Dali::AlphaFunction *)new Dali::AlphaFunction();
42814     } catch (std::out_of_range& e) {
42815       {
42816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42817       };
42818     } catch (std::exception& e) {
42819       {
42820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42821       };
42822     } catch (Dali::DaliException e) {
42823       {
42824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42825       };
42826     } catch (...) {
42827       {
42828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42829       };
42830     }
42831   }
42832
42833   jresult = (void *)result;
42834   return jresult;
42835 }
42836
42837
42838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_1(int jarg1) {
42839   void * jresult ;
42840   Dali::AlphaFunction::BuiltinFunction arg1 ;
42841   Dali::AlphaFunction *result = 0 ;
42842
42843   arg1 = (Dali::AlphaFunction::BuiltinFunction)jarg1;
42844   {
42845     try {
42846       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
42847     } catch (std::out_of_range& e) {
42848       {
42849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42850       };
42851     } catch (std::exception& e) {
42852       {
42853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42854       };
42855     } catch (Dali::DaliException e) {
42856       {
42857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42858       };
42859     } catch (...) {
42860       {
42861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42862       };
42863     }
42864   }
42865
42866   jresult = (void *)result;
42867   return jresult;
42868 }
42869
42870
42871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_2(void * jarg1) {
42872   void * jresult ;
42873   Dali::AlphaFunctionPrototype arg1 = (Dali::AlphaFunctionPrototype) 0 ;
42874   Dali::AlphaFunction *result = 0 ;
42875
42876   arg1 = (Dali::AlphaFunctionPrototype)jarg1;
42877   {
42878     try {
42879       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
42880     } catch (std::out_of_range& e) {
42881       {
42882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42883       };
42884     } catch (std::exception& e) {
42885       {
42886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42887       };
42888     } catch (Dali::DaliException e) {
42889       {
42890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42891       };
42892     } catch (...) {
42893       {
42894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42895       };
42896     }
42897   }
42898
42899   jresult = (void *)result;
42900   return jresult;
42901 }
42902
42903
42904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_3(void * jarg1, void * jarg2) {
42905   void * jresult ;
42906   Dali::Vector2 *arg1 = 0 ;
42907   Dali::Vector2 *arg2 = 0 ;
42908   Dali::AlphaFunction *result = 0 ;
42909
42910   arg1 = (Dali::Vector2 *)jarg1;
42911   if (!arg1) {
42912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
42913     return 0;
42914   }
42915   arg2 = (Dali::Vector2 *)jarg2;
42916   if (!arg2) {
42917     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
42918     return 0;
42919   }
42920   {
42921     try {
42922       result = (Dali::AlphaFunction *)new Dali::AlphaFunction((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
42923     } catch (std::out_of_range& e) {
42924       {
42925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42926       };
42927     } catch (std::exception& e) {
42928       {
42929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42930       };
42931     } catch (Dali::DaliException e) {
42932       {
42933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42934       };
42935     } catch (...) {
42936       {
42937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42938       };
42939     }
42940   }
42941
42942   jresult = (void *)result;
42943   return jresult;
42944 }
42945
42946
42947 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBezierControlPoints(void * jarg1) {
42948   void * jresult ;
42949   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42950   Dali::Vector4 result;
42951
42952   arg1 = (Dali::AlphaFunction *)jarg1;
42953   {
42954     try {
42955       result = ((Dali::AlphaFunction const *)arg1)->GetBezierControlPoints();
42956     } catch (std::out_of_range& e) {
42957       {
42958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42959       };
42960     } catch (std::exception& e) {
42961       {
42962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42963       };
42964     } catch (Dali::DaliException e) {
42965       {
42966         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42967       };
42968     } catch (...) {
42969       {
42970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42971       };
42972     }
42973   }
42974
42975   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
42976   return jresult;
42977 }
42978
42979
42980 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetCustomFunction(void * jarg1) {
42981   void * jresult ;
42982   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42983   Dali::AlphaFunctionPrototype result;
42984
42985   arg1 = (Dali::AlphaFunction *)jarg1;
42986   {
42987     try {
42988       result = (Dali::AlphaFunctionPrototype)((Dali::AlphaFunction const *)arg1)->GetCustomFunction();
42989     } catch (std::out_of_range& e) {
42990       {
42991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42992       };
42993     } catch (std::exception& e) {
42994       {
42995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42996       };
42997     } catch (Dali::DaliException e) {
42998       {
42999         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43000       };
43001     } catch (...) {
43002       {
43003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43004       };
43005     }
43006   }
43007
43008   jresult = (void *)result;
43009   return jresult;
43010 }
43011
43012
43013 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBuiltinFunction(void * jarg1) {
43014   int jresult ;
43015   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43016   Dali::AlphaFunction::BuiltinFunction result;
43017
43018   arg1 = (Dali::AlphaFunction *)jarg1;
43019   {
43020     try {
43021       result = (Dali::AlphaFunction::BuiltinFunction)((Dali::AlphaFunction const *)arg1)->GetBuiltinFunction();
43022     } catch (std::out_of_range& e) {
43023       {
43024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43025       };
43026     } catch (std::exception& e) {
43027       {
43028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43029       };
43030     } catch (Dali::DaliException e) {
43031       {
43032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43033       };
43034     } catch (...) {
43035       {
43036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43037       };
43038     }
43039   }
43040
43041   jresult = (int)result;
43042   return jresult;
43043 }
43044
43045
43046 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetMode(void * jarg1) {
43047   int jresult ;
43048   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43049   Dali::AlphaFunction::Mode result;
43050
43051   arg1 = (Dali::AlphaFunction *)jarg1;
43052   {
43053     try {
43054       result = (Dali::AlphaFunction::Mode)((Dali::AlphaFunction const *)arg1)->GetMode();
43055     } catch (std::out_of_range& e) {
43056       {
43057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43058       };
43059     } catch (std::exception& e) {
43060       {
43061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43062       };
43063     } catch (Dali::DaliException e) {
43064       {
43065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43066       };
43067     } catch (...) {
43068       {
43069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43070       };
43071     }
43072   }
43073
43074   jresult = (int)result;
43075   return jresult;
43076 }
43077
43078
43079 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AlphaFunction(void * jarg1) {
43080   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43081
43082   arg1 = (Dali::AlphaFunction *)jarg1;
43083   {
43084     try {
43085       delete arg1;
43086     } catch (std::out_of_range& e) {
43087       {
43088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43089       };
43090     } catch (std::exception& e) {
43091       {
43092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43093       };
43094     } catch (Dali::DaliException e) {
43095       {
43096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43097       };
43098     } catch (...) {
43099       {
43100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43101       };
43102     }
43103   }
43104
43105 }
43106
43107
43108 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_New() {
43109   void * jresult ;
43110   Dali::KeyFrames result;
43111
43112   {
43113     try {
43114       result = Dali::KeyFrames::New();
43115     } catch (std::out_of_range& e) {
43116       {
43117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43118       };
43119     } catch (std::exception& e) {
43120       {
43121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43122       };
43123     } catch (Dali::DaliException e) {
43124       {
43125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43126       };
43127     } catch (...) {
43128       {
43129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43130       };
43131     }
43132   }
43133
43134   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
43135   return jresult;
43136 }
43137
43138
43139 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_DownCast(void * jarg1) {
43140   void * jresult ;
43141   Dali::BaseHandle arg1 ;
43142   Dali::BaseHandle *argp1 ;
43143   Dali::KeyFrames result;
43144
43145   argp1 = (Dali::BaseHandle *)jarg1;
43146   if (!argp1) {
43147     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43148     return 0;
43149   }
43150   arg1 = *argp1;
43151   {
43152     try {
43153       result = Dali::KeyFrames::DownCast(arg1);
43154     } catch (std::out_of_range& e) {
43155       {
43156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43157       };
43158     } catch (std::exception& e) {
43159       {
43160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43161       };
43162     } catch (Dali::DaliException e) {
43163       {
43164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43165       };
43166     } catch (...) {
43167       {
43168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43169       };
43170     }
43171   }
43172
43173   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
43174   return jresult;
43175 }
43176
43177
43178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_0() {
43179   void * jresult ;
43180   Dali::KeyFrames *result = 0 ;
43181
43182   {
43183     try {
43184       result = (Dali::KeyFrames *)new Dali::KeyFrames();
43185     } catch (std::out_of_range& e) {
43186       {
43187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43188       };
43189     } catch (std::exception& e) {
43190       {
43191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43192       };
43193     } catch (Dali::DaliException e) {
43194       {
43195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43196       };
43197     } catch (...) {
43198       {
43199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43200       };
43201     }
43202   }
43203
43204   jresult = (void *)result;
43205   return jresult;
43206 }
43207
43208
43209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyFrames(void * jarg1) {
43210   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43211
43212   arg1 = (Dali::KeyFrames *)jarg1;
43213   {
43214     try {
43215       delete arg1;
43216     } catch (std::out_of_range& e) {
43217       {
43218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43219       };
43220     } catch (std::exception& e) {
43221       {
43222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43223       };
43224     } catch (Dali::DaliException e) {
43225       {
43226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43227       };
43228     } catch (...) {
43229       {
43230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43231       };
43232     }
43233   }
43234
43235 }
43236
43237
43238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_1(void * jarg1) {
43239   void * jresult ;
43240   Dali::KeyFrames *arg1 = 0 ;
43241   Dali::KeyFrames *result = 0 ;
43242
43243   arg1 = (Dali::KeyFrames *)jarg1;
43244   if (!arg1) {
43245     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
43246     return 0;
43247   }
43248   {
43249     try {
43250       result = (Dali::KeyFrames *)new Dali::KeyFrames((Dali::KeyFrames const &)*arg1);
43251     } catch (std::out_of_range& e) {
43252       {
43253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43254       };
43255     } catch (std::exception& e) {
43256       {
43257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43258       };
43259     } catch (Dali::DaliException e) {
43260       {
43261         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43262       };
43263     } catch (...) {
43264       {
43265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43266       };
43267     }
43268   }
43269
43270   jresult = (void *)result;
43271   return jresult;
43272 }
43273
43274
43275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_Assign(void * jarg1, void * jarg2) {
43276   void * jresult ;
43277   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43278   Dali::KeyFrames *arg2 = 0 ;
43279   Dali::KeyFrames *result = 0 ;
43280
43281   arg1 = (Dali::KeyFrames *)jarg1;
43282   arg2 = (Dali::KeyFrames *)jarg2;
43283   if (!arg2) {
43284     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
43285     return 0;
43286   }
43287   {
43288     try {
43289       result = (Dali::KeyFrames *) &(arg1)->operator =((Dali::KeyFrames const &)*arg2);
43290     } catch (std::out_of_range& e) {
43291       {
43292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43293       };
43294     } catch (std::exception& e) {
43295       {
43296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43297       };
43298     } catch (Dali::DaliException e) {
43299       {
43300         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43301       };
43302     } catch (...) {
43303       {
43304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43305       };
43306     }
43307   }
43308
43309   jresult = (void *)result;
43310   return jresult;
43311 }
43312
43313
43314 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_KeyFrames_GetType(void * jarg1) {
43315   int jresult ;
43316   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43317   Dali::Property::Type result;
43318
43319   arg1 = (Dali::KeyFrames *)jarg1;
43320   {
43321     try {
43322       result = (Dali::Property::Type)((Dali::KeyFrames const *)arg1)->GetType();
43323     } catch (std::out_of_range& e) {
43324       {
43325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43326       };
43327     } catch (std::exception& e) {
43328       {
43329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43330       };
43331     } catch (Dali::DaliException e) {
43332       {
43333         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43334       };
43335     } catch (...) {
43336       {
43337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43338       };
43339     }
43340   }
43341
43342   jresult = (int)result;
43343   return jresult;
43344 }
43345
43346
43347 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_0(void * jarg1, float jarg2, void * jarg3) {
43348   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43349   float arg2 ;
43350   Dali::Property::Value arg3 ;
43351   Dali::Property::Value *argp3 ;
43352
43353   arg1 = (Dali::KeyFrames *)jarg1;
43354   arg2 = (float)jarg2;
43355   argp3 = (Dali::Property::Value *)jarg3;
43356   if (!argp3) {
43357     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
43358     return ;
43359   }
43360   arg3 = *argp3;
43361   {
43362     try {
43363       (arg1)->Add(arg2,arg3);
43364     } catch (std::out_of_range& e) {
43365       {
43366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43367       };
43368     } catch (std::exception& e) {
43369       {
43370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43371       };
43372     } catch (Dali::DaliException e) {
43373       {
43374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43375       };
43376     } catch (...) {
43377       {
43378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43379       };
43380     }
43381   }
43382
43383 }
43384
43385
43386 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_1(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
43387   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43388   float arg2 ;
43389   Dali::Property::Value arg3 ;
43390   Dali::AlphaFunction arg4 ;
43391   Dali::Property::Value *argp3 ;
43392   Dali::AlphaFunction *argp4 ;
43393
43394   arg1 = (Dali::KeyFrames *)jarg1;
43395   arg2 = (float)jarg2;
43396   argp3 = (Dali::Property::Value *)jarg3;
43397   if (!argp3) {
43398     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
43399     return ;
43400   }
43401   arg3 = *argp3;
43402   argp4 = (Dali::AlphaFunction *)jarg4;
43403   if (!argp4) {
43404     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
43405     return ;
43406   }
43407   arg4 = *argp4;
43408   {
43409     try {
43410       (arg1)->Add(arg2,arg3,arg4);
43411     } catch (std::out_of_range& e) {
43412       {
43413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43414       };
43415     } catch (std::exception& e) {
43416       {
43417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43418       };
43419     } catch (Dali::DaliException e) {
43420       {
43421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43422       };
43423     } catch (...) {
43424       {
43425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43426       };
43427     }
43428   }
43429
43430 }
43431
43432
43433 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_POINTS_get() {
43434   int jresult ;
43435   int result;
43436
43437   result = (int)Dali::Path::Property::POINTS;
43438   jresult = (int)result;
43439   return jresult;
43440 }
43441
43442
43443 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_CONTROL_POINTS_get() {
43444   int jresult ;
43445   int result;
43446
43447   result = (int)Dali::Path::Property::CONTROL_POINTS;
43448   jresult = (int)result;
43449   return jresult;
43450 }
43451
43452
43453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path_Property() {
43454   void * jresult ;
43455   Dali::Path::Property *result = 0 ;
43456
43457   {
43458     try {
43459       result = (Dali::Path::Property *)new Dali::Path::Property();
43460     } catch (std::out_of_range& e) {
43461       {
43462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43463       };
43464     } catch (std::exception& e) {
43465       {
43466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43467       };
43468     } catch (Dali::DaliException e) {
43469       {
43470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43471       };
43472     } catch (...) {
43473       {
43474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43475       };
43476     }
43477   }
43478
43479   jresult = (void *)result;
43480   return jresult;
43481 }
43482
43483
43484 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path_Property(void * jarg1) {
43485   Dali::Path::Property *arg1 = (Dali::Path::Property *) 0 ;
43486
43487   arg1 = (Dali::Path::Property *)jarg1;
43488   {
43489     try {
43490       delete arg1;
43491     } catch (std::out_of_range& e) {
43492       {
43493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43494       };
43495     } catch (std::exception& e) {
43496       {
43497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43498       };
43499     } catch (Dali::DaliException e) {
43500       {
43501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43502       };
43503     } catch (...) {
43504       {
43505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43506       };
43507     }
43508   }
43509
43510 }
43511
43512
43513 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_New() {
43514   void * jresult ;
43515   Dali::Path result;
43516
43517   {
43518     try {
43519       result = Dali::Path::New();
43520     } catch (std::out_of_range& e) {
43521       {
43522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43523       };
43524     } catch (std::exception& e) {
43525       {
43526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43527       };
43528     } catch (Dali::DaliException e) {
43529       {
43530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43531       };
43532     } catch (...) {
43533       {
43534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43535       };
43536     }
43537   }
43538
43539   jresult = new Dali::Path((const Dali::Path &)result);
43540   return jresult;
43541 }
43542
43543
43544 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_DownCast(void * jarg1) {
43545   void * jresult ;
43546   Dali::BaseHandle arg1 ;
43547   Dali::BaseHandle *argp1 ;
43548   Dali::Path result;
43549
43550   argp1 = (Dali::BaseHandle *)jarg1;
43551   if (!argp1) {
43552     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43553     return 0;
43554   }
43555   arg1 = *argp1;
43556   {
43557     try {
43558       result = Dali::Path::DownCast(arg1);
43559     } catch (std::out_of_range& e) {
43560       {
43561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43562       };
43563     } catch (std::exception& e) {
43564       {
43565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43566       };
43567     } catch (Dali::DaliException e) {
43568       {
43569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43570       };
43571     } catch (...) {
43572       {
43573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43574       };
43575     }
43576   }
43577
43578   jresult = new Dali::Path((const Dali::Path &)result);
43579   return jresult;
43580 }
43581
43582
43583 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_0() {
43584   void * jresult ;
43585   Dali::Path *result = 0 ;
43586
43587   {
43588     try {
43589       result = (Dali::Path *)new Dali::Path();
43590     } catch (std::out_of_range& e) {
43591       {
43592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43593       };
43594     } catch (std::exception& e) {
43595       {
43596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43597       };
43598     } catch (Dali::DaliException e) {
43599       {
43600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43601       };
43602     } catch (...) {
43603       {
43604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43605       };
43606     }
43607   }
43608
43609   jresult = (void *)result;
43610   return jresult;
43611 }
43612
43613
43614 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path(void * jarg1) {
43615   Dali::Path *arg1 = (Dali::Path *) 0 ;
43616
43617   arg1 = (Dali::Path *)jarg1;
43618   {
43619     try {
43620       delete arg1;
43621     } catch (std::out_of_range& e) {
43622       {
43623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43624       };
43625     } catch (std::exception& e) {
43626       {
43627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43628       };
43629     } catch (Dali::DaliException e) {
43630       {
43631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43632       };
43633     } catch (...) {
43634       {
43635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43636       };
43637     }
43638   }
43639
43640 }
43641
43642
43643 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_1(void * jarg1) {
43644   void * jresult ;
43645   Dali::Path *arg1 = 0 ;
43646   Dali::Path *result = 0 ;
43647
43648   arg1 = (Dali::Path *)jarg1;
43649   if (!arg1) {
43650     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
43651     return 0;
43652   }
43653   {
43654     try {
43655       result = (Dali::Path *)new Dali::Path((Dali::Path const &)*arg1);
43656     } catch (std::out_of_range& e) {
43657       {
43658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43659       };
43660     } catch (std::exception& e) {
43661       {
43662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43663       };
43664     } catch (Dali::DaliException e) {
43665       {
43666         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43667       };
43668     } catch (...) {
43669       {
43670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43671       };
43672     }
43673   }
43674
43675   jresult = (void *)result;
43676   return jresult;
43677 }
43678
43679
43680 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_Assign(void * jarg1, void * jarg2) {
43681   void * jresult ;
43682   Dali::Path *arg1 = (Dali::Path *) 0 ;
43683   Dali::Path *arg2 = 0 ;
43684   Dali::Path *result = 0 ;
43685
43686   arg1 = (Dali::Path *)jarg1;
43687   arg2 = (Dali::Path *)jarg2;
43688   if (!arg2) {
43689     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
43690     return 0;
43691   }
43692   {
43693     try {
43694       result = (Dali::Path *) &(arg1)->operator =((Dali::Path const &)*arg2);
43695     } catch (std::out_of_range& e) {
43696       {
43697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43698       };
43699     } catch (std::exception& e) {
43700       {
43701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43702       };
43703     } catch (Dali::DaliException e) {
43704       {
43705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43706       };
43707     } catch (...) {
43708       {
43709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43710       };
43711     }
43712   }
43713
43714   jresult = (void *)result;
43715   return jresult;
43716 }
43717
43718
43719 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddPoint(void * jarg1, void * jarg2) {
43720   Dali::Path *arg1 = (Dali::Path *) 0 ;
43721   Dali::Vector3 *arg2 = 0 ;
43722
43723   arg1 = (Dali::Path *)jarg1;
43724   arg2 = (Dali::Vector3 *)jarg2;
43725   if (!arg2) {
43726     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43727     return ;
43728   }
43729   {
43730     try {
43731       (arg1)->AddPoint((Dali::Vector3 const &)*arg2);
43732     } catch (std::out_of_range& e) {
43733       {
43734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43735       };
43736     } catch (std::exception& e) {
43737       {
43738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43739       };
43740     } catch (Dali::DaliException e) {
43741       {
43742         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43743       };
43744     } catch (...) {
43745       {
43746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43747       };
43748     }
43749   }
43750
43751 }
43752
43753
43754 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddControlPoint(void * jarg1, void * jarg2) {
43755   Dali::Path *arg1 = (Dali::Path *) 0 ;
43756   Dali::Vector3 *arg2 = 0 ;
43757
43758   arg1 = (Dali::Path *)jarg1;
43759   arg2 = (Dali::Vector3 *)jarg2;
43760   if (!arg2) {
43761     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43762     return ;
43763   }
43764   {
43765     try {
43766       (arg1)->AddControlPoint((Dali::Vector3 const &)*arg2);
43767     } catch (std::out_of_range& e) {
43768       {
43769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43770       };
43771     } catch (std::exception& e) {
43772       {
43773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43774       };
43775     } catch (Dali::DaliException e) {
43776       {
43777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43778       };
43779     } catch (...) {
43780       {
43781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43782       };
43783     }
43784   }
43785
43786 }
43787
43788
43789 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_GenerateControlPoints(void * jarg1, float jarg2) {
43790   Dali::Path *arg1 = (Dali::Path *) 0 ;
43791   float arg2 ;
43792
43793   arg1 = (Dali::Path *)jarg1;
43794   arg2 = (float)jarg2;
43795   {
43796     try {
43797       (arg1)->GenerateControlPoints(arg2);
43798     } catch (std::out_of_range& e) {
43799       {
43800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43801       };
43802     } catch (std::exception& e) {
43803       {
43804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43805       };
43806     } catch (Dali::DaliException e) {
43807       {
43808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43809       };
43810     } catch (...) {
43811       {
43812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43813       };
43814     }
43815   }
43816
43817 }
43818
43819
43820 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_Sample(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
43821   Dali::Path *arg1 = (Dali::Path *) 0 ;
43822   float arg2 ;
43823   Dali::Vector3 *arg3 = 0 ;
43824   Dali::Vector3 *arg4 = 0 ;
43825
43826   arg1 = (Dali::Path *)jarg1;
43827   arg2 = (float)jarg2;
43828   arg3 = (Dali::Vector3 *)jarg3;
43829   if (!arg3) {
43830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
43831     return ;
43832   }
43833   arg4 = (Dali::Vector3 *)jarg4;
43834   if (!arg4) {
43835     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
43836     return ;
43837   }
43838   {
43839     try {
43840       ((Dali::Path const *)arg1)->Sample(arg2,*arg3,*arg4);
43841     } catch (std::out_of_range& e) {
43842       {
43843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43844       };
43845     } catch (std::exception& e) {
43846       {
43847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43848       };
43849     } catch (Dali::DaliException e) {
43850       {
43851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43852       };
43853     } catch (...) {
43854       {
43855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43856       };
43857     }
43858   }
43859
43860 }
43861
43862
43863 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetPoint(void * jarg1, unsigned long jarg2) {
43864   void * jresult ;
43865   Dali::Path *arg1 = (Dali::Path *) 0 ;
43866   size_t arg2 ;
43867   Dali::Vector3 *result = 0 ;
43868
43869   arg1 = (Dali::Path *)jarg1;
43870   arg2 = (size_t)jarg2;
43871   {
43872     try {
43873       result = (Dali::Vector3 *) &(arg1)->GetPoint(arg2);
43874     } catch (std::out_of_range& e) {
43875       {
43876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43877       };
43878     } catch (std::exception& e) {
43879       {
43880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43881       };
43882     } catch (Dali::DaliException e) {
43883       {
43884         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43885       };
43886     } catch (...) {
43887       {
43888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43889       };
43890     }
43891   }
43892
43893   jresult = (void *)result;
43894   return jresult;
43895 }
43896
43897
43898 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetControlPoint(void * jarg1, unsigned long jarg2) {
43899   void * jresult ;
43900   Dali::Path *arg1 = (Dali::Path *) 0 ;
43901   size_t arg2 ;
43902   Dali::Vector3 *result = 0 ;
43903
43904   arg1 = (Dali::Path *)jarg1;
43905   arg2 = (size_t)jarg2;
43906   {
43907     try {
43908       result = (Dali::Vector3 *) &(arg1)->GetControlPoint(arg2);
43909     } catch (std::out_of_range& e) {
43910       {
43911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43912       };
43913     } catch (std::exception& e) {
43914       {
43915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43916       };
43917     } catch (Dali::DaliException e) {
43918       {
43919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43920       };
43921     } catch (...) {
43922       {
43923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43924       };
43925     }
43926   }
43927
43928   jresult = (void *)result;
43929   return jresult;
43930 }
43931
43932
43933 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Path_GetPointCount(void * jarg1) {
43934   unsigned long jresult ;
43935   Dali::Path *arg1 = (Dali::Path *) 0 ;
43936   size_t result;
43937
43938   arg1 = (Dali::Path *)jarg1;
43939   {
43940     try {
43941       result = ((Dali::Path const *)arg1)->GetPointCount();
43942     } catch (std::out_of_range& e) {
43943       {
43944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43945       };
43946     } catch (std::exception& e) {
43947       {
43948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43949       };
43950     } catch (Dali::DaliException e) {
43951       {
43952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43953       };
43954     } catch (...) {
43955       {
43956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43957       };
43958     }
43959   }
43960
43961   jresult = (unsigned long)result;
43962   return jresult;
43963 }
43964
43965
43966 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_0(float jarg1) {
43967   void * jresult ;
43968   float arg1 ;
43969   Dali::TimePeriod *result = 0 ;
43970
43971   arg1 = (float)jarg1;
43972   {
43973     try {
43974       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1);
43975     } catch (std::out_of_range& e) {
43976       {
43977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43978       };
43979     } catch (std::exception& e) {
43980       {
43981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43982       };
43983     } catch (Dali::DaliException e) {
43984       {
43985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43986       };
43987     } catch (...) {
43988       {
43989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43990       };
43991     }
43992   }
43993
43994   jresult = (void *)result;
43995   return jresult;
43996 }
43997
43998
43999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_1(float jarg1, float jarg2) {
44000   void * jresult ;
44001   float arg1 ;
44002   float arg2 ;
44003   Dali::TimePeriod *result = 0 ;
44004
44005   arg1 = (float)jarg1;
44006   arg2 = (float)jarg2;
44007   {
44008     try {
44009       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1,arg2);
44010     } catch (std::out_of_range& e) {
44011       {
44012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44013       };
44014     } catch (std::exception& e) {
44015       {
44016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44017       };
44018     } catch (Dali::DaliException e) {
44019       {
44020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44021       };
44022     } catch (...) {
44023       {
44024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44025       };
44026     }
44027   }
44028
44029   jresult = (void *)result;
44030   return jresult;
44031 }
44032
44033
44034 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimePeriod(void * jarg1) {
44035   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44036
44037   arg1 = (Dali::TimePeriod *)jarg1;
44038   {
44039     try {
44040       delete arg1;
44041     } catch (std::out_of_range& e) {
44042       {
44043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44044       };
44045     } catch (std::exception& e) {
44046       {
44047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44048       };
44049     } catch (Dali::DaliException e) {
44050       {
44051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44052       };
44053     } catch (...) {
44054       {
44055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44056       };
44057     }
44058   }
44059
44060 }
44061
44062
44063 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_set(void * jarg1, float jarg2) {
44064   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44065   float arg2 ;
44066
44067   arg1 = (Dali::TimePeriod *)jarg1;
44068   arg2 = (float)jarg2;
44069   if (arg1) (arg1)->delaySeconds = arg2;
44070 }
44071
44072
44073 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_get(void * jarg1) {
44074   float jresult ;
44075   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44076   float result;
44077
44078   arg1 = (Dali::TimePeriod *)jarg1;
44079   result = (float) ((arg1)->delaySeconds);
44080   jresult = result;
44081   return jresult;
44082 }
44083
44084
44085 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_set(void * jarg1, float jarg2) {
44086   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44087   float arg2 ;
44088
44089   arg1 = (Dali::TimePeriod *)jarg1;
44090   arg2 = (float)jarg2;
44091   if (arg1) (arg1)->durationSeconds = arg2;
44092 }
44093
44094
44095 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_get(void * jarg1) {
44096   float jresult ;
44097   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44098   float result;
44099
44100   arg1 = (Dali::TimePeriod *)jarg1;
44101   result = (float) ((arg1)->durationSeconds);
44102   jresult = result;
44103   return jresult;
44104 }
44105
44106 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_VALUE_get() {
44107   int jresult ;
44108   int result;
44109
44110   result = (int)Dali::LinearConstrainer::Property::VALUE;
44111   jresult = (int)result;
44112   return jresult;
44113 }
44114
44115
44116 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_PROGRESS_get() {
44117   int jresult ;
44118   int result;
44119
44120   result = (int)Dali::LinearConstrainer::Property::PROGRESS;
44121   jresult = (int)result;
44122   return jresult;
44123 }
44124
44125
44126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer_Property() {
44127   void * jresult ;
44128   Dali::LinearConstrainer::Property *result = 0 ;
44129
44130   {
44131     try {
44132       result = (Dali::LinearConstrainer::Property *)new Dali::LinearConstrainer::Property();
44133     } catch (std::out_of_range& e) {
44134       {
44135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44136       };
44137     } catch (std::exception& e) {
44138       {
44139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44140       };
44141     } catch (Dali::DaliException e) {
44142       {
44143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44144       };
44145     } catch (...) {
44146       {
44147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44148       };
44149     }
44150   }
44151
44152   jresult = (void *)result;
44153   return jresult;
44154 }
44155
44156
44157 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer_Property(void * jarg1) {
44158   Dali::LinearConstrainer::Property *arg1 = (Dali::LinearConstrainer::Property *) 0 ;
44159
44160   arg1 = (Dali::LinearConstrainer::Property *)jarg1;
44161   {
44162     try {
44163       delete arg1;
44164     } catch (std::out_of_range& e) {
44165       {
44166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44167       };
44168     } catch (std::exception& e) {
44169       {
44170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44171       };
44172     } catch (Dali::DaliException e) {
44173       {
44174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44175       };
44176     } catch (...) {
44177       {
44178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44179       };
44180     }
44181   }
44182
44183 }
44184
44185
44186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_New() {
44187   void * jresult ;
44188   Dali::LinearConstrainer result;
44189
44190   {
44191     try {
44192       result = Dali::LinearConstrainer::New();
44193     } catch (std::out_of_range& e) {
44194       {
44195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44196       };
44197     } catch (std::exception& e) {
44198       {
44199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44200       };
44201     } catch (Dali::DaliException e) {
44202       {
44203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44204       };
44205     } catch (...) {
44206       {
44207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44208       };
44209     }
44210   }
44211
44212   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
44213   return jresult;
44214 }
44215
44216
44217 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_DownCast(void * jarg1) {
44218   void * jresult ;
44219   Dali::BaseHandle arg1 ;
44220   Dali::BaseHandle *argp1 ;
44221   Dali::LinearConstrainer result;
44222
44223   argp1 = (Dali::BaseHandle *)jarg1;
44224   if (!argp1) {
44225     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
44226     return 0;
44227   }
44228   arg1 = *argp1;
44229   {
44230     try {
44231       result = Dali::LinearConstrainer::DownCast(arg1);
44232     } catch (std::out_of_range& e) {
44233       {
44234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44235       };
44236     } catch (std::exception& e) {
44237       {
44238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44239       };
44240     } catch (Dali::DaliException e) {
44241       {
44242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44243       };
44244     } catch (...) {
44245       {
44246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44247       };
44248     }
44249   }
44250
44251   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
44252   return jresult;
44253 }
44254
44255
44256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_0() {
44257   void * jresult ;
44258   Dali::LinearConstrainer *result = 0 ;
44259
44260   {
44261     try {
44262       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer();
44263     } catch (std::out_of_range& e) {
44264       {
44265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44266       };
44267     } catch (std::exception& e) {
44268       {
44269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44270       };
44271     } catch (Dali::DaliException e) {
44272       {
44273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44274       };
44275     } catch (...) {
44276       {
44277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44278       };
44279     }
44280   }
44281
44282   jresult = (void *)result;
44283   return jresult;
44284 }
44285
44286
44287 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer(void * jarg1) {
44288   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44289
44290   arg1 = (Dali::LinearConstrainer *)jarg1;
44291   {
44292     try {
44293       delete arg1;
44294     } catch (std::out_of_range& e) {
44295       {
44296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44297       };
44298     } catch (std::exception& e) {
44299       {
44300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44301       };
44302     } catch (Dali::DaliException e) {
44303       {
44304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44305       };
44306     } catch (...) {
44307       {
44308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44309       };
44310     }
44311   }
44312
44313 }
44314
44315
44316 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_1(void * jarg1) {
44317   void * jresult ;
44318   Dali::LinearConstrainer *arg1 = 0 ;
44319   Dali::LinearConstrainer *result = 0 ;
44320
44321   arg1 = (Dali::LinearConstrainer *)jarg1;
44322   if (!arg1) {
44323     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
44324     return 0;
44325   }
44326   {
44327     try {
44328       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer((Dali::LinearConstrainer const &)*arg1);
44329     } catch (std::out_of_range& e) {
44330       {
44331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44332       };
44333     } catch (std::exception& e) {
44334       {
44335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44336       };
44337     } catch (Dali::DaliException e) {
44338       {
44339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44340       };
44341     } catch (...) {
44342       {
44343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44344       };
44345     }
44346   }
44347
44348   jresult = (void *)result;
44349   return jresult;
44350 }
44351
44352
44353 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_Assign(void * jarg1, void * jarg2) {
44354   void * jresult ;
44355   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44356   Dali::LinearConstrainer *arg2 = 0 ;
44357   Dali::LinearConstrainer *result = 0 ;
44358
44359   arg1 = (Dali::LinearConstrainer *)jarg1;
44360   arg2 = (Dali::LinearConstrainer *)jarg2;
44361   if (!arg2) {
44362     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
44363     return 0;
44364   }
44365   {
44366     try {
44367       result = (Dali::LinearConstrainer *) &(arg1)->operator =((Dali::LinearConstrainer const &)*arg2);
44368     } catch (std::out_of_range& e) {
44369       {
44370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44371       };
44372     } catch (std::exception& e) {
44373       {
44374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44375       };
44376     } catch (Dali::DaliException e) {
44377       {
44378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44379       };
44380     } catch (...) {
44381       {
44382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44383       };
44384     }
44385   }
44386
44387   jresult = (void *)result;
44388   return jresult;
44389 }
44390
44391
44392 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
44393   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44394   SwigValueWrapper< Dali::Property > arg2 ;
44395   SwigValueWrapper< Dali::Property > arg3 ;
44396   Dali::Vector2 *arg4 = 0 ;
44397   Dali::Vector2 *arg5 = 0 ;
44398   Dali::Property *argp2 ;
44399   Dali::Property *argp3 ;
44400
44401   arg1 = (Dali::LinearConstrainer *)jarg1;
44402   argp2 = (Dali::Property *)jarg2;
44403   if (!argp2) {
44404     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44405     return ;
44406   }
44407   arg2 = *argp2;
44408   argp3 = (Dali::Property *)jarg3;
44409   if (!argp3) {
44410     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44411     return ;
44412   }
44413   arg3 = *argp3;
44414   arg4 = (Dali::Vector2 *)jarg4;
44415   if (!arg4) {
44416     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44417     return ;
44418   }
44419   arg5 = (Dali::Vector2 *)jarg5;
44420   if (!arg5) {
44421     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44422     return ;
44423   }
44424   {
44425     try {
44426       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
44427     } catch (std::out_of_range& e) {
44428       {
44429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44430       };
44431     } catch (std::exception& e) {
44432       {
44433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44434       };
44435     } catch (Dali::DaliException e) {
44436       {
44437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44438       };
44439     } catch (...) {
44440       {
44441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44442       };
44443     }
44444   }
44445
44446 }
44447
44448
44449 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
44450   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44451   SwigValueWrapper< Dali::Property > arg2 ;
44452   SwigValueWrapper< Dali::Property > arg3 ;
44453   Dali::Vector2 *arg4 = 0 ;
44454   Dali::Property *argp2 ;
44455   Dali::Property *argp3 ;
44456
44457   arg1 = (Dali::LinearConstrainer *)jarg1;
44458   argp2 = (Dali::Property *)jarg2;
44459   if (!argp2) {
44460     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44461     return ;
44462   }
44463   arg2 = *argp2;
44464   argp3 = (Dali::Property *)jarg3;
44465   if (!argp3) {
44466     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44467     return ;
44468   }
44469   arg3 = *argp3;
44470   arg4 = (Dali::Vector2 *)jarg4;
44471   if (!arg4) {
44472     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44473     return ;
44474   }
44475   {
44476     try {
44477       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
44478     } catch (std::out_of_range& e) {
44479       {
44480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44481       };
44482     } catch (std::exception& e) {
44483       {
44484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44485       };
44486     } catch (Dali::DaliException e) {
44487       {
44488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44489       };
44490     } catch (...) {
44491       {
44492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44493       };
44494     }
44495   }
44496
44497 }
44498
44499
44500 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Remove(void * jarg1, void * jarg2) {
44501   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44502   Dali::Handle *arg2 = 0 ;
44503
44504   arg1 = (Dali::LinearConstrainer *)jarg1;
44505   arg2 = (Dali::Handle *)jarg2;
44506   if (!arg2) {
44507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
44508     return ;
44509   }
44510   {
44511     try {
44512       (arg1)->Remove(*arg2);
44513     } catch (std::out_of_range& e) {
44514       {
44515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44516       };
44517     } catch (std::exception& e) {
44518       {
44519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44520       };
44521     } catch (Dali::DaliException e) {
44522       {
44523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44524       };
44525     } catch (...) {
44526       {
44527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44528       };
44529     }
44530   }
44531
44532 }
44533
44534
44535 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_FORWARD_get() {
44536   int jresult ;
44537   int result;
44538
44539   result = (int)Dali::PathConstrainer::Property::FORWARD;
44540   jresult = (int)result;
44541   return jresult;
44542 }
44543
44544
44545 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_POINTS_get() {
44546   int jresult ;
44547   int result;
44548
44549   result = (int)Dali::PathConstrainer::Property::POINTS;
44550   jresult = (int)result;
44551   return jresult;
44552 }
44553
44554
44555 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_CONTROL_POINTS_get() {
44556   int jresult ;
44557   int result;
44558
44559   result = (int)Dali::PathConstrainer::Property::CONTROL_POINTS;
44560   jresult = (int)result;
44561   return jresult;
44562 }
44563
44564
44565 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer_Property() {
44566   void * jresult ;
44567   Dali::PathConstrainer::Property *result = 0 ;
44568
44569   {
44570     try {
44571       result = (Dali::PathConstrainer::Property *)new Dali::PathConstrainer::Property();
44572     } catch (std::out_of_range& e) {
44573       {
44574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44575       };
44576     } catch (std::exception& e) {
44577       {
44578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44579       };
44580     } catch (Dali::DaliException e) {
44581       {
44582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44583       };
44584     } catch (...) {
44585       {
44586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44587       };
44588     }
44589   }
44590
44591   jresult = (void *)result;
44592   return jresult;
44593 }
44594
44595
44596 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer_Property(void * jarg1) {
44597   Dali::PathConstrainer::Property *arg1 = (Dali::PathConstrainer::Property *) 0 ;
44598
44599   arg1 = (Dali::PathConstrainer::Property *)jarg1;
44600   {
44601     try {
44602       delete arg1;
44603     } catch (std::out_of_range& e) {
44604       {
44605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44606       };
44607     } catch (std::exception& e) {
44608       {
44609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44610       };
44611     } catch (Dali::DaliException e) {
44612       {
44613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44614       };
44615     } catch (...) {
44616       {
44617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44618       };
44619     }
44620   }
44621
44622 }
44623
44624
44625 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_New() {
44626   void * jresult ;
44627   Dali::PathConstrainer result;
44628
44629   {
44630     try {
44631       result = Dali::PathConstrainer::New();
44632     } catch (std::out_of_range& e) {
44633       {
44634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44635       };
44636     } catch (std::exception& e) {
44637       {
44638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44639       };
44640     } catch (Dali::DaliException e) {
44641       {
44642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44643       };
44644     } catch (...) {
44645       {
44646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44647       };
44648     }
44649   }
44650
44651   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
44652   return jresult;
44653 }
44654
44655
44656 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_DownCast(void * jarg1) {
44657   void * jresult ;
44658   Dali::BaseHandle arg1 ;
44659   Dali::BaseHandle *argp1 ;
44660   Dali::PathConstrainer result;
44661
44662   argp1 = (Dali::BaseHandle *)jarg1;
44663   if (!argp1) {
44664     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
44665     return 0;
44666   }
44667   arg1 = *argp1;
44668   {
44669     try {
44670       result = Dali::PathConstrainer::DownCast(arg1);
44671     } catch (std::out_of_range& e) {
44672       {
44673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44674       };
44675     } catch (std::exception& e) {
44676       {
44677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44678       };
44679     } catch (Dali::DaliException e) {
44680       {
44681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44682       };
44683     } catch (...) {
44684       {
44685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44686       };
44687     }
44688   }
44689
44690   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
44691   return jresult;
44692 }
44693
44694
44695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_0() {
44696   void * jresult ;
44697   Dali::PathConstrainer *result = 0 ;
44698
44699   {
44700     try {
44701       result = (Dali::PathConstrainer *)new Dali::PathConstrainer();
44702     } catch (std::out_of_range& e) {
44703       {
44704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44705       };
44706     } catch (std::exception& e) {
44707       {
44708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44709       };
44710     } catch (Dali::DaliException e) {
44711       {
44712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44713       };
44714     } catch (...) {
44715       {
44716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44717       };
44718     }
44719   }
44720
44721   jresult = (void *)result;
44722   return jresult;
44723 }
44724
44725
44726 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer(void * jarg1) {
44727   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44728
44729   arg1 = (Dali::PathConstrainer *)jarg1;
44730   {
44731     try {
44732       delete arg1;
44733     } catch (std::out_of_range& e) {
44734       {
44735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44736       };
44737     } catch (std::exception& e) {
44738       {
44739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44740       };
44741     } catch (Dali::DaliException e) {
44742       {
44743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44744       };
44745     } catch (...) {
44746       {
44747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44748       };
44749     }
44750   }
44751
44752 }
44753
44754
44755 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_1(void * jarg1) {
44756   void * jresult ;
44757   Dali::PathConstrainer *arg1 = 0 ;
44758   Dali::PathConstrainer *result = 0 ;
44759
44760   arg1 = (Dali::PathConstrainer *)jarg1;
44761   if (!arg1) {
44762     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
44763     return 0;
44764   }
44765   {
44766     try {
44767       result = (Dali::PathConstrainer *)new Dali::PathConstrainer((Dali::PathConstrainer const &)*arg1);
44768     } catch (std::out_of_range& e) {
44769       {
44770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44771       };
44772     } catch (std::exception& e) {
44773       {
44774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44775       };
44776     } catch (Dali::DaliException e) {
44777       {
44778         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44779       };
44780     } catch (...) {
44781       {
44782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44783       };
44784     }
44785   }
44786
44787   jresult = (void *)result;
44788   return jresult;
44789 }
44790
44791
44792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_Assign(void * jarg1, void * jarg2) {
44793   void * jresult ;
44794   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44795   Dali::PathConstrainer *arg2 = 0 ;
44796   Dali::PathConstrainer *result = 0 ;
44797
44798   arg1 = (Dali::PathConstrainer *)jarg1;
44799   arg2 = (Dali::PathConstrainer *)jarg2;
44800   if (!arg2) {
44801     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
44802     return 0;
44803   }
44804   {
44805     try {
44806       result = (Dali::PathConstrainer *) &(arg1)->operator =((Dali::PathConstrainer const &)*arg2);
44807     } catch (std::out_of_range& e) {
44808       {
44809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44810       };
44811     } catch (std::exception& e) {
44812       {
44813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44814       };
44815     } catch (Dali::DaliException e) {
44816       {
44817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44818       };
44819     } catch (...) {
44820       {
44821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44822       };
44823     }
44824   }
44825
44826   jresult = (void *)result;
44827   return jresult;
44828 }
44829
44830
44831 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
44832   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44833   SwigValueWrapper< Dali::Property > arg2 ;
44834   SwigValueWrapper< Dali::Property > arg3 ;
44835   Dali::Vector2 *arg4 = 0 ;
44836   Dali::Vector2 *arg5 = 0 ;
44837   Dali::Property *argp2 ;
44838   Dali::Property *argp3 ;
44839
44840   arg1 = (Dali::PathConstrainer *)jarg1;
44841   argp2 = (Dali::Property *)jarg2;
44842   if (!argp2) {
44843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44844     return ;
44845   }
44846   arg2 = *argp2;
44847   argp3 = (Dali::Property *)jarg3;
44848   if (!argp3) {
44849     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44850     return ;
44851   }
44852   arg3 = *argp3;
44853   arg4 = (Dali::Vector2 *)jarg4;
44854   if (!arg4) {
44855     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44856     return ;
44857   }
44858   arg5 = (Dali::Vector2 *)jarg5;
44859   if (!arg5) {
44860     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44861     return ;
44862   }
44863   {
44864     try {
44865       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
44866     } catch (std::out_of_range& e) {
44867       {
44868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44869       };
44870     } catch (std::exception& e) {
44871       {
44872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44873       };
44874     } catch (Dali::DaliException e) {
44875       {
44876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44877       };
44878     } catch (...) {
44879       {
44880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44881       };
44882     }
44883   }
44884
44885 }
44886
44887
44888 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
44889   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44890   SwigValueWrapper< Dali::Property > arg2 ;
44891   SwigValueWrapper< Dali::Property > arg3 ;
44892   Dali::Vector2 *arg4 = 0 ;
44893   Dali::Property *argp2 ;
44894   Dali::Property *argp3 ;
44895
44896   arg1 = (Dali::PathConstrainer *)jarg1;
44897   argp2 = (Dali::Property *)jarg2;
44898   if (!argp2) {
44899     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44900     return ;
44901   }
44902   arg2 = *argp2;
44903   argp3 = (Dali::Property *)jarg3;
44904   if (!argp3) {
44905     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44906     return ;
44907   }
44908   arg3 = *argp3;
44909   arg4 = (Dali::Vector2 *)jarg4;
44910   if (!arg4) {
44911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44912     return ;
44913   }
44914   {
44915     try {
44916       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
44917     } catch (std::out_of_range& e) {
44918       {
44919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44920       };
44921     } catch (std::exception& e) {
44922       {
44923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44924       };
44925     } catch (Dali::DaliException e) {
44926       {
44927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44928       };
44929     } catch (...) {
44930       {
44931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44932       };
44933     }
44934   }
44935
44936 }
44937
44938
44939 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Remove(void * jarg1, void * jarg2) {
44940   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44941   Dali::Handle *arg2 = 0 ;
44942
44943   arg1 = (Dali::PathConstrainer *)jarg1;
44944   arg2 = (Dali::Handle *)jarg2;
44945   if (!arg2) {
44946     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
44947     return ;
44948   }
44949   {
44950     try {
44951       (arg1)->Remove(*arg2);
44952     } catch (std::out_of_range& e) {
44953       {
44954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44955       };
44956     } catch (std::exception& e) {
44957       {
44958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44959       };
44960     } catch (Dali::DaliException e) {
44961       {
44962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44963       };
44964     } catch (...) {
44965       {
44966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44967       };
44968     }
44969   }
44970
44971 }
44972
44973
44974 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FittingModeDefault_get() {
44975   int jresult ;
44976   Dali::FittingMode::Type result;
44977
44978   result = (Dali::FittingMode::Type)(Dali::FittingMode::Type)Dali::FittingMode::DEFAULT;
44979   jresult = (int)result;
44980   return jresult;
44981 }
44982
44983
44984 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_DEFAULT_get() {
44985   int jresult ;
44986   Dali::SamplingMode::Type result;
44987
44988   result = (Dali::SamplingMode::Type)(Dali::SamplingMode::Type)Dali::SamplingMode::DEFAULT;
44989   jresult = (int)result;
44990   return jresult;
44991 }
44992
44993
44994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_0() {
44995   void * jresult ;
44996   Dali::BufferImage *result = 0 ;
44997
44998   {
44999     try {
45000       result = (Dali::BufferImage *)new Dali::BufferImage();
45001     } catch (std::out_of_range& e) {
45002       {
45003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45004       };
45005     } catch (std::exception& e) {
45006       {
45007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45008       };
45009     } catch (Dali::DaliException e) {
45010       {
45011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45012       };
45013     } catch (...) {
45014       {
45015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45016       };
45017     }
45018   }
45019
45020   jresult = (void *)result;
45021   return jresult;
45022 }
45023
45024
45025 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3) {
45026   void * jresult ;
45027   unsigned int arg1 ;
45028   unsigned int arg2 ;
45029   Dali::Pixel::Format arg3 ;
45030   Dali::BufferImage result;
45031
45032   arg1 = (unsigned int)jarg1;
45033   arg2 = (unsigned int)jarg2;
45034   arg3 = (Dali::Pixel::Format)jarg3;
45035   {
45036     try {
45037       result = Dali::BufferImage::New(arg1,arg2,arg3);
45038     } catch (std::out_of_range& e) {
45039       {
45040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45041       };
45042     } catch (std::exception& e) {
45043       {
45044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45045       };
45046     } catch (Dali::DaliException e) {
45047       {
45048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45049       };
45050     } catch (...) {
45051       {
45052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45053       };
45054     }
45055   }
45056
45057   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45058   return jresult;
45059 }
45060
45061
45062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
45063   void * jresult ;
45064   unsigned int arg1 ;
45065   unsigned int arg2 ;
45066   Dali::BufferImage result;
45067
45068   arg1 = (unsigned int)jarg1;
45069   arg2 = (unsigned int)jarg2;
45070   {
45071     try {
45072       result = Dali::BufferImage::New(arg1,arg2);
45073     } catch (std::out_of_range& e) {
45074       {
45075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45076       };
45077     } catch (std::exception& e) {
45078       {
45079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45080       };
45081     } catch (Dali::DaliException e) {
45082       {
45083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45084       };
45085     } catch (...) {
45086       {
45087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45088       };
45089     }
45090   }
45091
45092   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45093   return jresult;
45094 }
45095
45096
45097 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_2(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4, unsigned int jarg5) {
45098   void * jresult ;
45099   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
45100   unsigned int arg2 ;
45101   unsigned int arg3 ;
45102   Dali::Pixel::Format arg4 ;
45103   unsigned int arg5 ;
45104   Dali::BufferImage result;
45105
45106   arg1 = jarg1;
45107   arg2 = (unsigned int)jarg2;
45108   arg3 = (unsigned int)jarg3;
45109   arg4 = (Dali::Pixel::Format)jarg4;
45110   arg5 = (unsigned int)jarg5;
45111   {
45112     try {
45113       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4,arg5);
45114     } catch (std::out_of_range& e) {
45115       {
45116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45117       };
45118     } catch (std::exception& e) {
45119       {
45120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45121       };
45122     } catch (Dali::DaliException e) {
45123       {
45124         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45125       };
45126     } catch (...) {
45127       {
45128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45129       };
45130     }
45131   }
45132
45133   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45134
45135
45136   return jresult;
45137 }
45138
45139
45140 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_3(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4) {
45141   void * jresult ;
45142   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
45143   unsigned int arg2 ;
45144   unsigned int arg3 ;
45145   Dali::Pixel::Format arg4 ;
45146   Dali::BufferImage result;
45147
45148   arg1 = jarg1;
45149   arg2 = (unsigned int)jarg2;
45150   arg3 = (unsigned int)jarg3;
45151   arg4 = (Dali::Pixel::Format)jarg4;
45152   {
45153     try {
45154       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4);
45155     } catch (std::out_of_range& e) {
45156       {
45157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45158       };
45159     } catch (std::exception& e) {
45160       {
45161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45162       };
45163     } catch (Dali::DaliException e) {
45164       {
45165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45166       };
45167     } catch (...) {
45168       {
45169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45170       };
45171     }
45172   }
45173
45174   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45175
45176
45177   return jresult;
45178 }
45179
45180
45181 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_4(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3) {
45182   void * jresult ;
45183   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
45184   unsigned int arg2 ;
45185   unsigned int arg3 ;
45186   Dali::BufferImage result;
45187
45188   arg1 = jarg1;
45189   arg2 = (unsigned int)jarg2;
45190   arg3 = (unsigned int)jarg3;
45191   {
45192     try {
45193       result = Dali::BufferImage::New(arg1,arg2,arg3);
45194     } catch (std::out_of_range& e) {
45195       {
45196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45197       };
45198     } catch (std::exception& e) {
45199       {
45200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45201       };
45202     } catch (Dali::DaliException e) {
45203       {
45204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45205       };
45206     } catch (...) {
45207       {
45208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45209       };
45210     }
45211   }
45212
45213   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45214
45215
45216   return jresult;
45217 }
45218
45219
45220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_DownCast(void * jarg1) {
45221   void * jresult ;
45222   Dali::BaseHandle arg1 ;
45223   Dali::BaseHandle *argp1 ;
45224   Dali::BufferImage result;
45225
45226   argp1 = (Dali::BaseHandle *)jarg1;
45227   if (!argp1) {
45228     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
45229     return 0;
45230   }
45231   arg1 = *argp1;
45232   {
45233     try {
45234       result = Dali::BufferImage::DownCast(arg1);
45235     } catch (std::out_of_range& e) {
45236       {
45237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45238       };
45239     } catch (std::exception& e) {
45240       {
45241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45242       };
45243     } catch (Dali::DaliException e) {
45244       {
45245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45246       };
45247     } catch (...) {
45248       {
45249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45250       };
45251     }
45252   }
45253
45254   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45255   return jresult;
45256 }
45257
45258
45259 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BufferImage(void * jarg1) {
45260   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45261
45262   arg1 = (Dali::BufferImage *)jarg1;
45263   {
45264     try {
45265       delete arg1;
45266     } catch (std::out_of_range& e) {
45267       {
45268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45269       };
45270     } catch (std::exception& e) {
45271       {
45272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45273       };
45274     } catch (Dali::DaliException e) {
45275       {
45276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45277       };
45278     } catch (...) {
45279       {
45280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45281       };
45282     }
45283   }
45284
45285 }
45286
45287
45288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_1(void * jarg1) {
45289   void * jresult ;
45290   Dali::BufferImage *arg1 = 0 ;
45291   Dali::BufferImage *result = 0 ;
45292
45293   arg1 = (Dali::BufferImage *)jarg1;
45294   if (!arg1) {
45295     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
45296     return 0;
45297   }
45298   {
45299     try {
45300       result = (Dali::BufferImage *)new Dali::BufferImage((Dali::BufferImage const &)*arg1);
45301     } catch (std::out_of_range& e) {
45302       {
45303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45304       };
45305     } catch (std::exception& e) {
45306       {
45307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45308       };
45309     } catch (Dali::DaliException e) {
45310       {
45311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45312       };
45313     } catch (...) {
45314       {
45315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45316       };
45317     }
45318   }
45319
45320   jresult = (void *)result;
45321   return jresult;
45322 }
45323
45324
45325 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_Assign(void * jarg1, void * jarg2) {
45326   void * jresult ;
45327   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45328   Dali::BufferImage *arg2 = 0 ;
45329   Dali::BufferImage *result = 0 ;
45330
45331   arg1 = (Dali::BufferImage *)jarg1;
45332   arg2 = (Dali::BufferImage *)jarg2;
45333   if (!arg2) {
45334     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
45335     return 0;
45336   }
45337   {
45338     try {
45339       result = (Dali::BufferImage *) &(arg1)->operator =((Dali::BufferImage const &)*arg2);
45340     } catch (std::out_of_range& e) {
45341       {
45342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45343       };
45344     } catch (std::exception& e) {
45345       {
45346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45347       };
45348     } catch (Dali::DaliException e) {
45349       {
45350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45351       };
45352     } catch (...) {
45353       {
45354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45355       };
45356     }
45357   }
45358
45359   jresult = (void *)result;
45360   return jresult;
45361 }
45362
45363
45364 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_WHITE() {
45365   void * jresult ;
45366   Dali::BufferImage result;
45367
45368   {
45369     try {
45370       result = Dali::BufferImage::WHITE();
45371     } catch (std::out_of_range& e) {
45372       {
45373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45374       };
45375     } catch (std::exception& e) {
45376       {
45377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45378       };
45379     } catch (Dali::DaliException e) {
45380       {
45381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45382       };
45383     } catch (...) {
45384       {
45385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45386       };
45387     }
45388   }
45389
45390   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45391   return jresult;
45392 }
45393
45394
45395 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_GetBuffer(void * jarg1) {
45396   void * jresult ;
45397   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45398   Dali::PixelBuffer *result = 0 ;
45399
45400   arg1 = (Dali::BufferImage *)jarg1;
45401   {
45402     try {
45403       result = (Dali::PixelBuffer *)(arg1)->GetBuffer();
45404     } catch (std::out_of_range& e) {
45405       {
45406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45407       };
45408     } catch (std::exception& e) {
45409       {
45410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45411       };
45412     } catch (Dali::DaliException e) {
45413       {
45414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45415       };
45416     } catch (...) {
45417       {
45418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45419       };
45420     }
45421   }
45422
45423   jresult = (void *)result;
45424   return jresult;
45425 }
45426
45427
45428 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferSize(void * jarg1) {
45429   unsigned int jresult ;
45430   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45431   unsigned int result;
45432
45433   arg1 = (Dali::BufferImage *)jarg1;
45434   {
45435     try {
45436       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferSize();
45437     } catch (std::out_of_range& e) {
45438       {
45439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45440       };
45441     } catch (std::exception& e) {
45442       {
45443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45444       };
45445     } catch (Dali::DaliException e) {
45446       {
45447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45448       };
45449     } catch (...) {
45450       {
45451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45452       };
45453     }
45454   }
45455
45456   jresult = result;
45457   return jresult;
45458 }
45459
45460
45461 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferStride(void * jarg1) {
45462   unsigned int jresult ;
45463   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45464   unsigned int result;
45465
45466   arg1 = (Dali::BufferImage *)jarg1;
45467   {
45468     try {
45469       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferStride();
45470     } catch (std::out_of_range& e) {
45471       {
45472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45473       };
45474     } catch (std::exception& e) {
45475       {
45476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45477       };
45478     } catch (Dali::DaliException e) {
45479       {
45480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45481       };
45482     } catch (...) {
45483       {
45484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45485       };
45486     }
45487   }
45488
45489   jresult = result;
45490   return jresult;
45491 }
45492
45493
45494 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BufferImage_GetPixelFormat(void * jarg1) {
45495   int jresult ;
45496   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45497   Dali::Pixel::Format result;
45498
45499   arg1 = (Dali::BufferImage *)jarg1;
45500   {
45501     try {
45502       result = (Dali::Pixel::Format)((Dali::BufferImage const *)arg1)->GetPixelFormat();
45503     } catch (std::out_of_range& e) {
45504       {
45505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45506       };
45507     } catch (std::exception& e) {
45508       {
45509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45510       };
45511     } catch (Dali::DaliException e) {
45512       {
45513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45514       };
45515     } catch (...) {
45516       {
45517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45518       };
45519     }
45520   }
45521
45522   jresult = (int)result;
45523   return jresult;
45524 }
45525
45526
45527 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BufferImage_Update__SWIG_0(void * jarg1) {
45528   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45529
45530   arg1 = (Dali::BufferImage *)jarg1;
45531   {
45532     try {
45533       (arg1)->Update();
45534     } catch (std::out_of_range& e) {
45535       {
45536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45537       };
45538     } catch (std::exception& e) {
45539       {
45540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45541       };
45542     } catch (Dali::DaliException e) {
45543       {
45544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45545       };
45546     } catch (...) {
45547       {
45548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45549       };
45550     }
45551   }
45552
45553 }
45554
45555
45556 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BufferImage_Update__SWIG_1(void * jarg1, void * jarg2) {
45557   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45558   SwigValueWrapper< Dali::Rect< unsigned int > > arg2 ;
45559   Dali::RectArea *argp2 ;
45560
45561   arg1 = (Dali::BufferImage *)jarg1;
45562   argp2 = (Dali::RectArea *)jarg2;
45563   if (!argp2) {
45564     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RectArea", 0);
45565     return ;
45566   }
45567   arg2 = *argp2;
45568   {
45569     try {
45570       (arg1)->Update(arg2);
45571     } catch (std::out_of_range& e) {
45572       {
45573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45574       };
45575     } catch (std::exception& e) {
45576       {
45577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45578       };
45579     } catch (Dali::DaliException e) {
45580       {
45581         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45582       };
45583     } catch (...) {
45584       {
45585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45586       };
45587     }
45588   }
45589
45590 }
45591
45592
45593 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_IsDataExternal(void * jarg1) {
45594   unsigned int jresult ;
45595   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45596   bool result;
45597
45598   arg1 = (Dali::BufferImage *)jarg1;
45599   {
45600     try {
45601       result = (bool)((Dali::BufferImage const *)arg1)->IsDataExternal();
45602     } catch (std::out_of_range& e) {
45603       {
45604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45605       };
45606     } catch (std::exception& e) {
45607       {
45608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45609       };
45610     } catch (Dali::DaliException e) {
45611       {
45612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45613       };
45614     } catch (...) {
45615       {
45616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45617       };
45618     }
45619   }
45620
45621   jresult = result;
45622   return jresult;
45623 }
45624
45625
45626 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EncodedBufferImage__SWIG_0() {
45627   void * jresult ;
45628   Dali::EncodedBufferImage *result = 0 ;
45629
45630   {
45631     try {
45632       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage();
45633     } catch (std::out_of_range& e) {
45634       {
45635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45636       };
45637     } catch (std::exception& e) {
45638       {
45639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45640       };
45641     } catch (Dali::DaliException e) {
45642       {
45643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45644       };
45645     } catch (...) {
45646       {
45647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45648       };
45649     }
45650   }
45651
45652   jresult = (void *)result;
45653   return jresult;
45654 }
45655
45656
45657 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_0(void * jarg1, unsigned long jarg2) {
45658   void * jresult ;
45659   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
45660   std::size_t arg2 ;
45661   Dali::EncodedBufferImage result;
45662
45663   arg1 = (uint8_t *)jarg1;
45664   arg2 = (std::size_t)jarg2;
45665   {
45666     try {
45667       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2);
45668     } catch (std::out_of_range& e) {
45669       {
45670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45671       };
45672     } catch (std::exception& e) {
45673       {
45674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45675       };
45676     } catch (Dali::DaliException e) {
45677       {
45678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45679       };
45680     } catch (...) {
45681       {
45682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45683       };
45684     }
45685   }
45686
45687   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45688   return jresult;
45689 }
45690
45691
45692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
45693   void * jresult ;
45694   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
45695   std::size_t arg2 ;
45696   Dali::ImageDimensions arg3 ;
45697   Dali::FittingMode::Type arg4 ;
45698   Dali::SamplingMode::Type arg5 ;
45699   bool arg6 ;
45700   Dali::ImageDimensions *argp3 ;
45701   Dali::EncodedBufferImage result;
45702
45703   arg1 = (uint8_t *)jarg1;
45704   arg2 = (std::size_t)jarg2;
45705   argp3 = (Dali::ImageDimensions *)jarg3;
45706   if (!argp3) {
45707     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
45708     return 0;
45709   }
45710   arg3 = *argp3;
45711   arg4 = (Dali::FittingMode::Type)jarg4;
45712   arg5 = (Dali::SamplingMode::Type)jarg5;
45713   arg6 = jarg6 ? true : false;
45714   {
45715     try {
45716       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5,arg6);
45717     } catch (std::out_of_range& e) {
45718       {
45719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45720       };
45721     } catch (std::exception& e) {
45722       {
45723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45724       };
45725     } catch (Dali::DaliException e) {
45726       {
45727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45728       };
45729     } catch (...) {
45730       {
45731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45732       };
45733     }
45734   }
45735
45736   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45737   return jresult;
45738 }
45739
45740
45741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_2(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5) {
45742   void * jresult ;
45743   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
45744   std::size_t arg2 ;
45745   Dali::ImageDimensions arg3 ;
45746   Dali::FittingMode::Type arg4 ;
45747   Dali::SamplingMode::Type arg5 ;
45748   Dali::ImageDimensions *argp3 ;
45749   Dali::EncodedBufferImage result;
45750
45751   arg1 = (uint8_t *)jarg1;
45752   arg2 = (std::size_t)jarg2;
45753   argp3 = (Dali::ImageDimensions *)jarg3;
45754   if (!argp3) {
45755     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
45756     return 0;
45757   }
45758   arg3 = *argp3;
45759   arg4 = (Dali::FittingMode::Type)jarg4;
45760   arg5 = (Dali::SamplingMode::Type)jarg5;
45761   {
45762     try {
45763       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5);
45764     } catch (std::out_of_range& e) {
45765       {
45766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45767       };
45768     } catch (std::exception& e) {
45769       {
45770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45771       };
45772     } catch (Dali::DaliException e) {
45773       {
45774         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45775       };
45776     } catch (...) {
45777       {
45778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45779       };
45780     }
45781   }
45782
45783   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45784   return jresult;
45785 }
45786
45787
45788 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_DownCast(void * jarg1) {
45789   void * jresult ;
45790   Dali::BaseHandle arg1 ;
45791   Dali::BaseHandle *argp1 ;
45792   Dali::EncodedBufferImage result;
45793
45794   argp1 = (Dali::BaseHandle *)jarg1;
45795   if (!argp1) {
45796     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
45797     return 0;
45798   }
45799   arg1 = *argp1;
45800   {
45801     try {
45802       result = Dali::EncodedBufferImage::DownCast(arg1);
45803     } catch (std::out_of_range& e) {
45804       {
45805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45806       };
45807     } catch (std::exception& e) {
45808       {
45809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45810       };
45811     } catch (Dali::DaliException e) {
45812       {
45813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45814       };
45815     } catch (...) {
45816       {
45817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45818       };
45819     }
45820   }
45821
45822   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45823   return jresult;
45824 }
45825
45826
45827 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_EncodedBufferImage(void * jarg1) {
45828   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
45829
45830   arg1 = (Dali::EncodedBufferImage *)jarg1;
45831   {
45832     try {
45833       delete arg1;
45834     } catch (std::out_of_range& e) {
45835       {
45836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45837       };
45838     } catch (std::exception& e) {
45839       {
45840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45841       };
45842     } catch (Dali::DaliException e) {
45843       {
45844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45845       };
45846     } catch (...) {
45847       {
45848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45849       };
45850     }
45851   }
45852
45853 }
45854
45855
45856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EncodedBufferImage__SWIG_1(void * jarg1) {
45857   void * jresult ;
45858   Dali::EncodedBufferImage *arg1 = 0 ;
45859   Dali::EncodedBufferImage *result = 0 ;
45860
45861   arg1 = (Dali::EncodedBufferImage *)jarg1;
45862   if (!arg1) {
45863     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
45864     return 0;
45865   }
45866   {
45867     try {
45868       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage((Dali::EncodedBufferImage const &)*arg1);
45869     } catch (std::out_of_range& e) {
45870       {
45871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45872       };
45873     } catch (std::exception& e) {
45874       {
45875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45876       };
45877     } catch (Dali::DaliException e) {
45878       {
45879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45880       };
45881     } catch (...) {
45882       {
45883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45884       };
45885     }
45886   }
45887
45888   jresult = (void *)result;
45889   return jresult;
45890 }
45891
45892
45893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_Assign(void * jarg1, void * jarg2) {
45894   void * jresult ;
45895   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
45896   Dali::EncodedBufferImage *arg2 = 0 ;
45897   Dali::EncodedBufferImage *result = 0 ;
45898
45899   arg1 = (Dali::EncodedBufferImage *)jarg1;
45900   arg2 = (Dali::EncodedBufferImage *)jarg2;
45901   if (!arg2) {
45902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
45903     return 0;
45904   }
45905   {
45906     try {
45907       result = (Dali::EncodedBufferImage *) &(arg1)->operator =((Dali::EncodedBufferImage const &)*arg2);
45908     } catch (std::out_of_range& e) {
45909       {
45910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45911       };
45912     } catch (std::exception& e) {
45913       {
45914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45915       };
45916     } catch (Dali::DaliException e) {
45917       {
45918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45919       };
45920     } catch (...) {
45921       {
45922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45923       };
45924     }
45925   }
45926
45927   jresult = (void *)result;
45928   return jresult;
45929 }
45930
45931
45932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_0() {
45933   void * jresult ;
45934   Dali::NativeImage *result = 0 ;
45935
45936   {
45937     try {
45938       result = (Dali::NativeImage *)new Dali::NativeImage();
45939     } catch (std::out_of_range& e) {
45940       {
45941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45942       };
45943     } catch (std::exception& e) {
45944       {
45945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45946       };
45947     } catch (Dali::DaliException e) {
45948       {
45949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45950       };
45951     } catch (...) {
45952       {
45953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45954       };
45955     }
45956   }
45957
45958   jresult = (void *)result;
45959   return jresult;
45960 }
45961
45962
45963 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NativeImage(void * jarg1) {
45964   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
45965
45966   arg1 = (Dali::NativeImage *)jarg1;
45967   {
45968     try {
45969       delete arg1;
45970     } catch (std::out_of_range& e) {
45971       {
45972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45973       };
45974     } catch (std::exception& e) {
45975       {
45976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45977       };
45978     } catch (Dali::DaliException e) {
45979       {
45980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45981       };
45982     } catch (...) {
45983       {
45984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45985       };
45986     }
45987   }
45988
45989 }
45990
45991
45992 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_1(void * jarg1) {
45993   void * jresult ;
45994   Dali::NativeImage *arg1 = 0 ;
45995   Dali::NativeImage *result = 0 ;
45996
45997   arg1 = (Dali::NativeImage *)jarg1;
45998   if (!arg1) {
45999     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
46000     return 0;
46001   }
46002   {
46003     try {
46004       result = (Dali::NativeImage *)new Dali::NativeImage((Dali::NativeImage const &)*arg1);
46005     } catch (std::out_of_range& e) {
46006       {
46007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46008       };
46009     } catch (std::exception& e) {
46010       {
46011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46012       };
46013     } catch (Dali::DaliException e) {
46014       {
46015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46016       };
46017     } catch (...) {
46018       {
46019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46020       };
46021     }
46022   }
46023
46024   jresult = (void *)result;
46025   return jresult;
46026 }
46027
46028
46029 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_Assign(void * jarg1, void * jarg2) {
46030   void * jresult ;
46031   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46032   Dali::NativeImage *arg2 = 0 ;
46033   Dali::NativeImage *result = 0 ;
46034
46035   arg1 = (Dali::NativeImage *)jarg1;
46036   arg2 = (Dali::NativeImage *)jarg2;
46037   if (!arg2) {
46038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
46039     return 0;
46040   }
46041   {
46042     try {
46043       result = (Dali::NativeImage *) &(arg1)->operator =((Dali::NativeImage const &)*arg2);
46044     } catch (std::out_of_range& e) {
46045       {
46046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46047       };
46048     } catch (std::exception& e) {
46049       {
46050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46051       };
46052     } catch (Dali::DaliException e) {
46053       {
46054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46055       };
46056     } catch (...) {
46057       {
46058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46059       };
46060     }
46061   }
46062
46063   jresult = (void *)result;
46064   return jresult;
46065 }
46066
46067
46068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImage_CreateGlTexture(void * jarg1) {
46069   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46070
46071   arg1 = (Dali::NativeImage *)jarg1;
46072   {
46073     try {
46074       (arg1)->CreateGlTexture();
46075     } catch (std::out_of_range& e) {
46076       {
46077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46078       };
46079     } catch (std::exception& e) {
46080       {
46081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46082       };
46083     } catch (Dali::DaliException e) {
46084       {
46085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46086       };
46087     } catch (...) {
46088       {
46089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46090       };
46091     }
46092   }
46093
46094 }
46095
46096
46097 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_New(void * jarg1) {
46098   void * jresult ;
46099   NativeImageInterface *arg1 = 0 ;
46100   Dali::NativeImage result;
46101
46102   arg1 = (NativeImageInterface *)jarg1;
46103   if (!arg1) {
46104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
46105     return 0;
46106   }
46107   {
46108     try {
46109       result = Dali::NativeImage::New(*arg1);
46110     } catch (std::out_of_range& e) {
46111       {
46112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46113       };
46114     } catch (std::exception& e) {
46115       {
46116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46117       };
46118     } catch (Dali::DaliException e) {
46119       {
46120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46121       };
46122     } catch (...) {
46123       {
46124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46125       };
46126     }
46127   }
46128
46129   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
46130   return jresult;
46131 }
46132
46133
46134 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_DownCast(void * jarg1) {
46135   void * jresult ;
46136   Dali::BaseHandle arg1 ;
46137   Dali::BaseHandle *argp1 ;
46138   Dali::NativeImage result;
46139
46140   argp1 = (Dali::BaseHandle *)jarg1;
46141   if (!argp1) {
46142     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
46143     return 0;
46144   }
46145   arg1 = *argp1;
46146   {
46147     try {
46148       result = Dali::NativeImage::DownCast(arg1);
46149     } catch (std::out_of_range& e) {
46150       {
46151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46152       };
46153     } catch (std::exception& e) {
46154       {
46155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46156       };
46157     } catch (Dali::DaliException e) {
46158       {
46159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46160       };
46161     } catch (...) {
46162       {
46163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46164       };
46165     }
46166   }
46167
46168   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
46169   return jresult;
46170 }
46171
46172
46173 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomFragmentPreFix(void * jarg1) {
46174   char * jresult ;
46175   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46176   char *result = 0 ;
46177
46178   arg1 = (Dali::NativeImage *)jarg1;
46179   {
46180     try {
46181       result = (char *)(arg1)->GetCustomFragmentPreFix();
46182     } catch (std::out_of_range& e) {
46183       {
46184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46185       };
46186     } catch (std::exception& e) {
46187       {
46188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46189       };
46190     } catch (Dali::DaliException e) {
46191       {
46192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46193       };
46194     } catch (...) {
46195       {
46196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46197       };
46198     }
46199   }
46200
46201   jresult = SWIG_csharp_string_callback((const char *)result);
46202   return jresult;
46203 }
46204
46205
46206 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomSamplerTypename(void * jarg1) {
46207   char * jresult ;
46208   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46209   char *result = 0 ;
46210
46211   arg1 = (Dali::NativeImage *)jarg1;
46212   {
46213     try {
46214       result = (char *)(arg1)->GetCustomSamplerTypename();
46215     } catch (std::out_of_range& e) {
46216       {
46217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46218       };
46219     } catch (std::exception& e) {
46220       {
46221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46222       };
46223     } catch (Dali::DaliException e) {
46224       {
46225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46226       };
46227     } catch (...) {
46228       {
46229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46230       };
46231     }
46232   }
46233
46234   jresult = SWIG_csharp_string_callback((const char *)result);
46235   return jresult;
46236 }
46237
46238
46239 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionCreate(void * jarg1) {
46240   unsigned int jresult ;
46241   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46242   bool result;
46243
46244   arg1 = (Dali::NativeImageInterface *)jarg1;
46245   {
46246     try {
46247       result = (bool)(arg1)->GlExtensionCreate();
46248     } catch (std::out_of_range& e) {
46249       {
46250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46251       };
46252     } catch (std::exception& e) {
46253       {
46254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46255       };
46256     } catch (Dali::DaliException e) {
46257       {
46258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46259       };
46260     } catch (...) {
46261       {
46262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46263       };
46264     }
46265   }
46266
46267   jresult = result;
46268   return jresult;
46269 }
46270
46271
46272 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionDestroy(void * jarg1) {
46273   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46274
46275   arg1 = (Dali::NativeImageInterface *)jarg1;
46276   {
46277     try {
46278       (arg1)->GlExtensionDestroy();
46279     } catch (std::out_of_range& e) {
46280       {
46281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46282       };
46283     } catch (std::exception& e) {
46284       {
46285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46286       };
46287     } catch (Dali::DaliException e) {
46288       {
46289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46290       };
46291     } catch (...) {
46292       {
46293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46294       };
46295     }
46296   }
46297
46298 }
46299
46300
46301 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_TargetTexture(void * jarg1) {
46302   unsigned int jresult ;
46303   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46304   unsigned int result;
46305
46306   arg1 = (Dali::NativeImageInterface *)jarg1;
46307   {
46308     try {
46309       result = (unsigned int)(arg1)->TargetTexture();
46310     } catch (std::out_of_range& e) {
46311       {
46312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46313       };
46314     } catch (std::exception& e) {
46315       {
46316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46317       };
46318     } catch (Dali::DaliException e) {
46319       {
46320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46321       };
46322     } catch (...) {
46323       {
46324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46325       };
46326     }
46327   }
46328
46329   jresult = result;
46330   return jresult;
46331 }
46332
46333
46334 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_PrepareTexture(void * jarg1) {
46335   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46336
46337   arg1 = (Dali::NativeImageInterface *)jarg1;
46338   {
46339     try {
46340       (arg1)->PrepareTexture();
46341     } catch (std::out_of_range& e) {
46342       {
46343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46344       };
46345     } catch (std::exception& e) {
46346       {
46347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46348       };
46349     } catch (Dali::DaliException e) {
46350       {
46351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46352       };
46353     } catch (...) {
46354       {
46355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46356       };
46357     }
46358   }
46359
46360 }
46361
46362
46363 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetWidth(void * jarg1) {
46364   unsigned int jresult ;
46365   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46366   unsigned int result;
46367
46368   arg1 = (Dali::NativeImageInterface *)jarg1;
46369   {
46370     try {
46371       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetWidth();
46372     } catch (std::out_of_range& e) {
46373       {
46374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46375       };
46376     } catch (std::exception& e) {
46377       {
46378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46379       };
46380     } catch (Dali::DaliException e) {
46381       {
46382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46383       };
46384     } catch (...) {
46385       {
46386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46387       };
46388     }
46389   }
46390
46391   jresult = result;
46392   return jresult;
46393 }
46394
46395
46396 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetHeight(void * jarg1) {
46397   unsigned int jresult ;
46398   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46399   unsigned int result;
46400
46401   arg1 = (Dali::NativeImageInterface *)jarg1;
46402   {
46403     try {
46404       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetHeight();
46405     } catch (std::out_of_range& e) {
46406       {
46407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46408       };
46409     } catch (std::exception& e) {
46410       {
46411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46412       };
46413     } catch (Dali::DaliException e) {
46414       {
46415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46416       };
46417     } catch (...) {
46418       {
46419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46420       };
46421     }
46422   }
46423
46424   jresult = result;
46425   return jresult;
46426 }
46427
46428
46429 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_RequiresBlending(void * jarg1) {
46430   unsigned int jresult ;
46431   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46432   bool result;
46433
46434   arg1 = (Dali::NativeImageInterface *)jarg1;
46435   {
46436     try {
46437       result = (bool)((Dali::NativeImageInterface const *)arg1)->RequiresBlending();
46438     } catch (std::out_of_range& e) {
46439       {
46440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46441       };
46442     } catch (std::exception& e) {
46443       {
46444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46445       };
46446     } catch (Dali::DaliException e) {
46447       {
46448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46449       };
46450     } catch (...) {
46451       {
46452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46453       };
46454     }
46455   }
46456
46457   jresult = result;
46458   return jresult;
46459 }
46460
46461
46462 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_GetImageSize(char * jarg1) {
46463   void * jresult ;
46464   std::string *arg1 = 0 ;
46465   Dali::ImageDimensions result;
46466
46467   if (!jarg1) {
46468     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46469     return 0;
46470   }
46471   std::string arg1_str(jarg1);
46472   arg1 = &arg1_str;
46473   {
46474     try {
46475       result = Dali::ResourceImage::GetImageSize((std::string const &)*arg1);
46476     } catch (std::out_of_range& e) {
46477       {
46478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46479       };
46480     } catch (std::exception& e) {
46481       {
46482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46483       };
46484     } catch (Dali::DaliException e) {
46485       {
46486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46487       };
46488     } catch (...) {
46489       {
46490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46491       };
46492     }
46493   }
46494
46495   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
46496
46497   //argout typemap for const std::string&
46498
46499   return jresult;
46500 }
46501
46502
46503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_0() {
46504   void * jresult ;
46505   Dali::ResourceImage *result = 0 ;
46506
46507   {
46508     try {
46509       result = (Dali::ResourceImage *)new Dali::ResourceImage();
46510     } catch (std::out_of_range& e) {
46511       {
46512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46513       };
46514     } catch (std::exception& e) {
46515       {
46516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46517       };
46518     } catch (Dali::DaliException e) {
46519       {
46520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46521       };
46522     } catch (...) {
46523       {
46524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46525       };
46526     }
46527   }
46528
46529   jresult = (void *)result;
46530   return jresult;
46531 }
46532
46533
46534 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImage(void * jarg1) {
46535   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
46536
46537   arg1 = (Dali::ResourceImage *)jarg1;
46538   {
46539     try {
46540       delete arg1;
46541     } catch (std::out_of_range& e) {
46542       {
46543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46544       };
46545     } catch (std::exception& e) {
46546       {
46547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46548       };
46549     } catch (Dali::DaliException e) {
46550       {
46551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46552       };
46553     } catch (...) {
46554       {
46555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46556       };
46557     }
46558   }
46559
46560 }
46561
46562
46563 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_1(void * jarg1) {
46564   void * jresult ;
46565   Dali::ResourceImage *arg1 = 0 ;
46566   Dali::ResourceImage *result = 0 ;
46567
46568   arg1 = (Dali::ResourceImage *)jarg1;
46569   if (!arg1) {
46570     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
46571     return 0;
46572   }
46573   {
46574     try {
46575       result = (Dali::ResourceImage *)new Dali::ResourceImage((Dali::ResourceImage const &)*arg1);
46576     } catch (std::out_of_range& e) {
46577       {
46578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46579       };
46580     } catch (std::exception& e) {
46581       {
46582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46583       };
46584     } catch (Dali::DaliException e) {
46585       {
46586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46587       };
46588     } catch (...) {
46589       {
46590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46591       };
46592     }
46593   }
46594
46595   jresult = (void *)result;
46596   return jresult;
46597 }
46598
46599
46600 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_Assign(void * jarg1, void * jarg2) {
46601   void * jresult ;
46602   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
46603   Dali::ResourceImage *arg2 = 0 ;
46604   Dali::ResourceImage *result = 0 ;
46605
46606   arg1 = (Dali::ResourceImage *)jarg1;
46607   arg2 = (Dali::ResourceImage *)jarg2;
46608   if (!arg2) {
46609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
46610     return 0;
46611   }
46612   {
46613     try {
46614       result = (Dali::ResourceImage *) &(arg1)->operator =((Dali::ResourceImage const &)*arg2);
46615     } catch (std::out_of_range& e) {
46616       {
46617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46618       };
46619     } catch (std::exception& e) {
46620       {
46621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46622       };
46623     } catch (Dali::DaliException e) {
46624       {
46625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46626       };
46627     } catch (...) {
46628       {
46629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46630       };
46631     }
46632   }
46633
46634   jresult = (void *)result;
46635   return jresult;
46636 }
46637
46638
46639 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_0(char * jarg1, unsigned int jarg2) {
46640   void * jresult ;
46641   std::string *arg1 = 0 ;
46642   bool arg2 ;
46643   Dali::ResourceImage result;
46644
46645   if (!jarg1) {
46646     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46647     return 0;
46648   }
46649   std::string arg1_str(jarg1);
46650   arg1 = &arg1_str;
46651   arg2 = jarg2 ? true : false;
46652   {
46653     try {
46654       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
46655     } catch (std::out_of_range& e) {
46656       {
46657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46658       };
46659     } catch (std::exception& e) {
46660       {
46661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46662       };
46663     } catch (Dali::DaliException e) {
46664       {
46665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46666       };
46667     } catch (...) {
46668       {
46669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46670       };
46671     }
46672   }
46673
46674   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46675
46676   //argout typemap for const std::string&
46677
46678   return jresult;
46679 }
46680
46681
46682 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_1(char * jarg1) {
46683   void * jresult ;
46684   std::string *arg1 = 0 ;
46685   Dali::ResourceImage result;
46686
46687   if (!jarg1) {
46688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46689     return 0;
46690   }
46691   std::string arg1_str(jarg1);
46692   arg1 = &arg1_str;
46693   {
46694     try {
46695       result = Dali::ResourceImage::New((std::string const &)*arg1);
46696     } catch (std::out_of_range& e) {
46697       {
46698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46699       };
46700     } catch (std::exception& e) {
46701       {
46702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46703       };
46704     } catch (Dali::DaliException e) {
46705       {
46706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46707       };
46708     } catch (...) {
46709       {
46710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46711       };
46712     }
46713   }
46714
46715   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46716
46717   //argout typemap for const std::string&
46718
46719   return jresult;
46720 }
46721
46722
46723 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
46724   void * jresult ;
46725   std::string *arg1 = 0 ;
46726   Dali::ImageDimensions arg2 ;
46727   Dali::FittingMode::Type arg3 ;
46728   Dali::SamplingMode::Type arg4 ;
46729   bool arg5 ;
46730   Dali::ImageDimensions *argp2 ;
46731   Dali::ResourceImage result;
46732
46733   if (!jarg1) {
46734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46735     return 0;
46736   }
46737   std::string arg1_str(jarg1);
46738   arg1 = &arg1_str;
46739   argp2 = (Dali::ImageDimensions *)jarg2;
46740   if (!argp2) {
46741     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46742     return 0;
46743   }
46744   arg2 = *argp2;
46745   arg3 = (Dali::FittingMode::Type)jarg3;
46746   arg4 = (Dali::SamplingMode::Type)jarg4;
46747   arg5 = jarg5 ? true : false;
46748   {
46749     try {
46750       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4,arg5);
46751     } catch (std::out_of_range& e) {
46752       {
46753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46754       };
46755     } catch (std::exception& e) {
46756       {
46757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46758       };
46759     } catch (Dali::DaliException e) {
46760       {
46761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46762       };
46763     } catch (...) {
46764       {
46765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46766       };
46767     }
46768   }
46769
46770   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46771
46772   //argout typemap for const std::string&
46773
46774   return jresult;
46775 }
46776
46777
46778 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_3(char * jarg1, void * jarg2, int jarg3, int jarg4) {
46779   void * jresult ;
46780   std::string *arg1 = 0 ;
46781   Dali::ImageDimensions arg2 ;
46782   Dali::FittingMode::Type arg3 ;
46783   Dali::SamplingMode::Type arg4 ;
46784   Dali::ImageDimensions *argp2 ;
46785   Dali::ResourceImage result;
46786
46787   if (!jarg1) {
46788     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46789     return 0;
46790   }
46791   std::string arg1_str(jarg1);
46792   arg1 = &arg1_str;
46793   argp2 = (Dali::ImageDimensions *)jarg2;
46794   if (!argp2) {
46795     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46796     return 0;
46797   }
46798   arg2 = *argp2;
46799   arg3 = (Dali::FittingMode::Type)jarg3;
46800   arg4 = (Dali::SamplingMode::Type)jarg4;
46801   {
46802     try {
46803       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4);
46804     } catch (std::out_of_range& e) {
46805       {
46806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46807       };
46808     } catch (std::exception& e) {
46809       {
46810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46811       };
46812     } catch (Dali::DaliException e) {
46813       {
46814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46815       };
46816     } catch (...) {
46817       {
46818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46819       };
46820     }
46821   }
46822
46823   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46824
46825   //argout typemap for const std::string&
46826
46827   return jresult;
46828 }
46829
46830
46831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_4(char * jarg1, void * jarg2, int jarg3) {
46832   void * jresult ;
46833   std::string *arg1 = 0 ;
46834   Dali::ImageDimensions arg2 ;
46835   Dali::FittingMode::Type arg3 ;
46836   Dali::ImageDimensions *argp2 ;
46837   Dali::ResourceImage result;
46838
46839   if (!jarg1) {
46840     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46841     return 0;
46842   }
46843   std::string arg1_str(jarg1);
46844   arg1 = &arg1_str;
46845   argp2 = (Dali::ImageDimensions *)jarg2;
46846   if (!argp2) {
46847     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46848     return 0;
46849   }
46850   arg2 = *argp2;
46851   arg3 = (Dali::FittingMode::Type)jarg3;
46852   {
46853     try {
46854       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3);
46855     } catch (std::out_of_range& e) {
46856       {
46857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46858       };
46859     } catch (std::exception& e) {
46860       {
46861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46862       };
46863     } catch (Dali::DaliException e) {
46864       {
46865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46866       };
46867     } catch (...) {
46868       {
46869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46870       };
46871     }
46872   }
46873
46874   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46875
46876   //argout typemap for const std::string&
46877
46878   return jresult;
46879 }
46880
46881
46882 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_5(char * jarg1, void * jarg2) {
46883   void * jresult ;
46884   std::string *arg1 = 0 ;
46885   Dali::ImageDimensions arg2 ;
46886   Dali::ImageDimensions *argp2 ;
46887   Dali::ResourceImage result;
46888
46889   if (!jarg1) {
46890     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46891     return 0;
46892   }
46893   std::string arg1_str(jarg1);
46894   arg1 = &arg1_str;
46895   argp2 = (Dali::ImageDimensions *)jarg2;
46896   if (!argp2) {
46897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46898     return 0;
46899   }
46900   arg2 = *argp2;
46901   {
46902     try {
46903       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
46904     } catch (std::out_of_range& e) {
46905       {
46906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46907       };
46908     } catch (std::exception& e) {
46909       {
46910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46911       };
46912     } catch (Dali::DaliException e) {
46913       {
46914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46915       };
46916     } catch (...) {
46917       {
46918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46919       };
46920     }
46921   }
46922
46923   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46924
46925   //argout typemap for const std::string&
46926
46927   return jresult;
46928 }
46929
46930
46931 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_DownCast(void * jarg1) {
46932   void * jresult ;
46933   Dali::BaseHandle arg1 ;
46934   Dali::BaseHandle *argp1 ;
46935   Dali::ResourceImage result;
46936
46937   argp1 = (Dali::BaseHandle *)jarg1;
46938   if (!argp1) {
46939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
46940     return 0;
46941   }
46942   arg1 = *argp1;
46943   {
46944     try {
46945       result = Dali::ResourceImage::DownCast(arg1);
46946     } catch (std::out_of_range& e) {
46947       {
46948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46949       };
46950     } catch (std::exception& e) {
46951       {
46952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46953       };
46954     } catch (Dali::DaliException e) {
46955       {
46956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46957       };
46958     } catch (...) {
46959       {
46960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46961       };
46962     }
46963   }
46964
46965   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46966   return jresult;
46967 }
46968
46969
46970 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResourceImage_GetLoadingState(void * jarg1) {
46971   int jresult ;
46972   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
46973   Dali::LoadingState result;
46974
46975   arg1 = (Dali::ResourceImage *)jarg1;
46976   {
46977     try {
46978       result = (Dali::LoadingState)((Dali::ResourceImage const *)arg1)->GetLoadingState();
46979     } catch (std::out_of_range& e) {
46980       {
46981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46982       };
46983     } catch (std::exception& e) {
46984       {
46985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46986       };
46987     } catch (Dali::DaliException e) {
46988       {
46989         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46990       };
46991     } catch (...) {
46992       {
46993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46994       };
46995     }
46996   }
46997
46998   jresult = (int)result;
46999   return jresult;
47000 }
47001
47002
47003 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ResourceImage_GetUrl(void * jarg1) {
47004   char * jresult ;
47005   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
47006   std::string result;
47007
47008   arg1 = (Dali::ResourceImage *)jarg1;
47009   {
47010     try {
47011       result = ((Dali::ResourceImage const *)arg1)->GetUrl();
47012     } catch (std::out_of_range& e) {
47013       {
47014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47015       };
47016     } catch (std::exception& e) {
47017       {
47018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47019       };
47020     } catch (Dali::DaliException e) {
47021       {
47022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47023       };
47024     } catch (...) {
47025       {
47026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47027       };
47028     }
47029   }
47030
47031   jresult = SWIG_csharp_string_callback((&result)->c_str());
47032   return jresult;
47033 }
47034
47035
47036 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImage_Reload(void * jarg1) {
47037   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
47038
47039   arg1 = (Dali::ResourceImage *)jarg1;
47040   {
47041     try {
47042       (arg1)->Reload();
47043     } catch (std::out_of_range& e) {
47044       {
47045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47046       };
47047     } catch (std::exception& e) {
47048       {
47049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47050       };
47051     } catch (Dali::DaliException e) {
47052       {
47053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47054       };
47055     } catch (...) {
47056       {
47057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47058       };
47059     }
47060   }
47061
47062 }
47063
47064
47065 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_LoadingFinishedSignal(void * jarg1) {
47066   void * jresult ;
47067   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
47068   Dali::ResourceImage::ResourceImageSignal *result = 0 ;
47069
47070   arg1 = (Dali::ResourceImage *)jarg1;
47071   {
47072     try {
47073       result = (Dali::ResourceImage::ResourceImageSignal *) &(arg1)->LoadingFinishedSignal();
47074     } catch (std::out_of_range& e) {
47075       {
47076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47077       };
47078     } catch (std::exception& e) {
47079       {
47080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47081       };
47082     } catch (Dali::DaliException e) {
47083       {
47084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47085       };
47086     } catch (...) {
47087       {
47088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47089       };
47090     }
47091   }
47092
47093   jresult = (void *)result;
47094   return jresult;
47095 }
47096
47097
47098 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_0() {
47099   void * jresult ;
47100   Dali::FrameBufferImage *result = 0 ;
47101
47102   {
47103     try {
47104       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage();
47105     } catch (std::out_of_range& e) {
47106       {
47107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47108       };
47109     } catch (std::exception& e) {
47110       {
47111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47112       };
47113     } catch (Dali::DaliException e) {
47114       {
47115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47116       };
47117     } catch (...) {
47118       {
47119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47120       };
47121     }
47122   }
47123
47124   jresult = (void *)result;
47125   return jresult;
47126 }
47127
47128
47129 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3, int jarg4) {
47130   void * jresult ;
47131   unsigned int arg1 ;
47132   unsigned int arg2 ;
47133   Dali::Pixel::Format arg3 ;
47134   Dali::RenderBuffer::Format arg4 ;
47135   Dali::FrameBufferImage result;
47136
47137   arg1 = (unsigned int)jarg1;
47138   arg2 = (unsigned int)jarg2;
47139   arg3 = (Dali::Pixel::Format)jarg3;
47140   arg4 = (Dali::RenderBuffer::Format)jarg4;
47141   {
47142     try {
47143       result = Dali::FrameBufferImage::New(arg1,arg2,arg3,arg4);
47144     } catch (std::out_of_range& e) {
47145       {
47146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47147       };
47148     } catch (std::exception& e) {
47149       {
47150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47151       };
47152     } catch (Dali::DaliException e) {
47153       {
47154         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47155       };
47156     } catch (...) {
47157       {
47158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47159       };
47160     }
47161   }
47162
47163   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47164   return jresult;
47165 }
47166
47167
47168 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2, int jarg3) {
47169   void * jresult ;
47170   unsigned int arg1 ;
47171   unsigned int arg2 ;
47172   Dali::Pixel::Format arg3 ;
47173   Dali::FrameBufferImage result;
47174
47175   arg1 = (unsigned int)jarg1;
47176   arg2 = (unsigned int)jarg2;
47177   arg3 = (Dali::Pixel::Format)jarg3;
47178   {
47179     try {
47180       result = Dali::FrameBufferImage::New(arg1,arg2,arg3);
47181     } catch (std::out_of_range& e) {
47182       {
47183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47184       };
47185     } catch (std::exception& e) {
47186       {
47187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47188       };
47189     } catch (Dali::DaliException e) {
47190       {
47191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47192       };
47193     } catch (...) {
47194       {
47195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47196       };
47197     }
47198   }
47199
47200   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47201   return jresult;
47202 }
47203
47204
47205 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
47206   void * jresult ;
47207   unsigned int arg1 ;
47208   unsigned int arg2 ;
47209   Dali::FrameBufferImage result;
47210
47211   arg1 = (unsigned int)jarg1;
47212   arg2 = (unsigned int)jarg2;
47213   {
47214     try {
47215       result = Dali::FrameBufferImage::New(arg1,arg2);
47216     } catch (std::out_of_range& e) {
47217       {
47218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47219       };
47220     } catch (std::exception& e) {
47221       {
47222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47223       };
47224     } catch (Dali::DaliException e) {
47225       {
47226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47227       };
47228     } catch (...) {
47229       {
47230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47231       };
47232     }
47233   }
47234
47235   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47236   return jresult;
47237 }
47238
47239
47240 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_3(unsigned int jarg1) {
47241   void * jresult ;
47242   unsigned int arg1 ;
47243   Dali::FrameBufferImage result;
47244
47245   arg1 = (unsigned int)jarg1;
47246   {
47247     try {
47248       result = Dali::FrameBufferImage::New(arg1);
47249     } catch (std::out_of_range& e) {
47250       {
47251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47252       };
47253     } catch (std::exception& e) {
47254       {
47255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47256       };
47257     } catch (Dali::DaliException e) {
47258       {
47259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47260       };
47261     } catch (...) {
47262       {
47263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47264       };
47265     }
47266   }
47267
47268   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47269   return jresult;
47270 }
47271
47272
47273 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_4() {
47274   void * jresult ;
47275   Dali::FrameBufferImage result;
47276
47277   {
47278     try {
47279       result = Dali::FrameBufferImage::New();
47280     } catch (std::out_of_range& e) {
47281       {
47282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47283       };
47284     } catch (std::exception& e) {
47285       {
47286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47287       };
47288     } catch (Dali::DaliException e) {
47289       {
47290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47291       };
47292     } catch (...) {
47293       {
47294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47295       };
47296     }
47297   }
47298
47299   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47300   return jresult;
47301 }
47302
47303
47304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_5(void * jarg1) {
47305   void * jresult ;
47306   Dali::NativeImageInterface *arg1 = 0 ;
47307   Dali::FrameBufferImage result;
47308
47309   arg1 = (Dali::NativeImageInterface *)jarg1;
47310   if (!arg1) {
47311     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImageInterface & type is null", 0);
47312     return 0;
47313   }
47314   {
47315     try {
47316       result = Dali::FrameBufferImage::New(*arg1);
47317     } catch (std::out_of_range& e) {
47318       {
47319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47320       };
47321     } catch (std::exception& e) {
47322       {
47323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47324       };
47325     } catch (Dali::DaliException e) {
47326       {
47327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47328       };
47329     } catch (...) {
47330       {
47331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47332       };
47333     }
47334   }
47335
47336   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47337   return jresult;
47338 }
47339
47340
47341 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_DownCast(void * jarg1) {
47342   void * jresult ;
47343   Dali::BaseHandle arg1 ;
47344   Dali::BaseHandle *argp1 ;
47345   Dali::FrameBufferImage result;
47346
47347   argp1 = (Dali::BaseHandle *)jarg1;
47348   if (!argp1) {
47349     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
47350     return 0;
47351   }
47352   arg1 = *argp1;
47353   {
47354     try {
47355       result = Dali::FrameBufferImage::DownCast(arg1);
47356     } catch (std::out_of_range& e) {
47357       {
47358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47359       };
47360     } catch (std::exception& e) {
47361       {
47362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47363       };
47364     } catch (Dali::DaliException e) {
47365       {
47366         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47367       };
47368     } catch (...) {
47369       {
47370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47371       };
47372     }
47373   }
47374
47375   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47376   return jresult;
47377 }
47378
47379
47380 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBufferImage(void * jarg1) {
47381   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
47382
47383   arg1 = (Dali::FrameBufferImage *)jarg1;
47384   {
47385     try {
47386       delete arg1;
47387     } catch (std::out_of_range& e) {
47388       {
47389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47390       };
47391     } catch (std::exception& e) {
47392       {
47393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47394       };
47395     } catch (Dali::DaliException e) {
47396       {
47397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47398       };
47399     } catch (...) {
47400       {
47401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47402       };
47403     }
47404   }
47405
47406 }
47407
47408
47409 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_1(void * jarg1) {
47410   void * jresult ;
47411   Dali::FrameBufferImage *arg1 = 0 ;
47412   Dali::FrameBufferImage *result = 0 ;
47413
47414   arg1 = (Dali::FrameBufferImage *)jarg1;
47415   if (!arg1) {
47416     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
47417     return 0;
47418   }
47419   {
47420     try {
47421       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage((Dali::FrameBufferImage const &)*arg1);
47422     } catch (std::out_of_range& e) {
47423       {
47424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47425       };
47426     } catch (std::exception& e) {
47427       {
47428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47429       };
47430     } catch (Dali::DaliException e) {
47431       {
47432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47433       };
47434     } catch (...) {
47435       {
47436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47437       };
47438     }
47439   }
47440
47441   jresult = (void *)result;
47442   return jresult;
47443 }
47444
47445
47446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_Assign(void * jarg1, void * jarg2) {
47447   void * jresult ;
47448   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
47449   Dali::FrameBufferImage *arg2 = 0 ;
47450   Dali::FrameBufferImage *result = 0 ;
47451
47452   arg1 = (Dali::FrameBufferImage *)jarg1;
47453   arg2 = (Dali::FrameBufferImage *)jarg2;
47454   if (!arg2) {
47455     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
47456     return 0;
47457   }
47458   {
47459     try {
47460       result = (Dali::FrameBufferImage *) &(arg1)->operator =((Dali::FrameBufferImage const &)*arg2);
47461     } catch (std::out_of_range& e) {
47462       {
47463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47464       };
47465     } catch (std::exception& e) {
47466       {
47467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47468       };
47469     } catch (Dali::DaliException e) {
47470       {
47471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47472       };
47473     } catch (...) {
47474       {
47475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47476       };
47477     }
47478   }
47479
47480   jresult = (void *)result;
47481   return jresult;
47482 }
47483
47484
47485 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NinePatchImage__SWIG_0() {
47486   void * jresult ;
47487   Dali::NinePatchImage *result = 0 ;
47488
47489   {
47490     try {
47491       result = (Dali::NinePatchImage *)new Dali::NinePatchImage();
47492     } catch (std::out_of_range& e) {
47493       {
47494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47495       };
47496     } catch (std::exception& e) {
47497       {
47498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47499       };
47500     } catch (Dali::DaliException e) {
47501       {
47502         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47503       };
47504     } catch (...) {
47505       {
47506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47507       };
47508     }
47509   }
47510
47511   jresult = (void *)result;
47512   return jresult;
47513 }
47514
47515
47516 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_New(char * jarg1) {
47517   void * jresult ;
47518   std::string *arg1 = 0 ;
47519   Dali::NinePatchImage result;
47520
47521   if (!jarg1) {
47522     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
47523     return 0;
47524   }
47525   std::string arg1_str(jarg1);
47526   arg1 = &arg1_str;
47527   {
47528     try {
47529       result = Dali::NinePatchImage::New((std::string const &)*arg1);
47530     } catch (std::out_of_range& e) {
47531       {
47532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47533       };
47534     } catch (std::exception& e) {
47535       {
47536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47537       };
47538     } catch (Dali::DaliException e) {
47539       {
47540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47541       };
47542     } catch (...) {
47543       {
47544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47545       };
47546     }
47547   }
47548
47549   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
47550
47551   //argout typemap for const std::string&
47552
47553   return jresult;
47554 }
47555
47556
47557 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_DownCast(void * jarg1) {
47558   void * jresult ;
47559   Dali::BaseHandle arg1 ;
47560   Dali::BaseHandle *argp1 ;
47561   Dali::NinePatchImage result;
47562
47563   argp1 = (Dali::BaseHandle *)jarg1;
47564   if (!argp1) {
47565     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
47566     return 0;
47567   }
47568   arg1 = *argp1;
47569   {
47570     try {
47571       result = Dali::NinePatchImage::DownCast(arg1);
47572     } catch (std::out_of_range& e) {
47573       {
47574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47575       };
47576     } catch (std::exception& e) {
47577       {
47578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47579       };
47580     } catch (Dali::DaliException e) {
47581       {
47582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47583       };
47584     } catch (...) {
47585       {
47586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47587       };
47588     }
47589   }
47590
47591   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
47592   return jresult;
47593 }
47594
47595
47596 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NinePatchImage(void * jarg1) {
47597   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47598
47599   arg1 = (Dali::NinePatchImage *)jarg1;
47600   {
47601     try {
47602       delete arg1;
47603     } catch (std::out_of_range& e) {
47604       {
47605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47606       };
47607     } catch (std::exception& e) {
47608       {
47609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47610       };
47611     } catch (Dali::DaliException e) {
47612       {
47613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47614       };
47615     } catch (...) {
47616       {
47617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47618       };
47619     }
47620   }
47621
47622 }
47623
47624
47625 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NinePatchImage__SWIG_1(void * jarg1) {
47626   void * jresult ;
47627   Dali::NinePatchImage *arg1 = 0 ;
47628   Dali::NinePatchImage *result = 0 ;
47629
47630   arg1 = (Dali::NinePatchImage *)jarg1;
47631   if (!arg1) {
47632     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
47633     return 0;
47634   }
47635   {
47636     try {
47637       result = (Dali::NinePatchImage *)new Dali::NinePatchImage((Dali::NinePatchImage const &)*arg1);
47638     } catch (std::out_of_range& e) {
47639       {
47640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47641       };
47642     } catch (std::exception& e) {
47643       {
47644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47645       };
47646     } catch (Dali::DaliException e) {
47647       {
47648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47649       };
47650     } catch (...) {
47651       {
47652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47653       };
47654     }
47655   }
47656
47657   jresult = (void *)result;
47658   return jresult;
47659 }
47660
47661
47662 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_Assign(void * jarg1, void * jarg2) {
47663   void * jresult ;
47664   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47665   Dali::NinePatchImage *arg2 = 0 ;
47666   Dali::NinePatchImage *result = 0 ;
47667
47668   arg1 = (Dali::NinePatchImage *)jarg1;
47669   arg2 = (Dali::NinePatchImage *)jarg2;
47670   if (!arg2) {
47671     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
47672     return 0;
47673   }
47674   {
47675     try {
47676       result = (Dali::NinePatchImage *) &(arg1)->operator =((Dali::NinePatchImage const &)*arg2);
47677     } catch (std::out_of_range& e) {
47678       {
47679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47680       };
47681     } catch (std::exception& e) {
47682       {
47683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47684       };
47685     } catch (Dali::DaliException e) {
47686       {
47687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47688       };
47689     } catch (...) {
47690       {
47691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47692       };
47693     }
47694   }
47695
47696   jresult = (void *)result;
47697   return jresult;
47698 }
47699
47700
47701 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchBorders(void * jarg1) {
47702   void * jresult ;
47703   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47704   Dali::Vector4 result;
47705
47706   arg1 = (Dali::NinePatchImage *)jarg1;
47707   {
47708     try {
47709       result = (arg1)->GetStretchBorders();
47710     } catch (std::out_of_range& e) {
47711       {
47712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47713       };
47714     } catch (std::exception& e) {
47715       {
47716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47717       };
47718     } catch (Dali::DaliException e) {
47719       {
47720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47721       };
47722     } catch (...) {
47723       {
47724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47725       };
47726     }
47727   }
47728
47729   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
47730   return jresult;
47731 }
47732
47733
47734 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsX(void * jarg1) {
47735   void * jresult ;
47736   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47737   Dali::NinePatchImage::StretchRanges *result = 0 ;
47738
47739   arg1 = (Dali::NinePatchImage *)jarg1;
47740   {
47741     try {
47742       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsX();
47743     } catch (std::out_of_range& e) {
47744       {
47745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47746       };
47747     } catch (std::exception& e) {
47748       {
47749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47750       };
47751     } catch (Dali::DaliException e) {
47752       {
47753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47754       };
47755     } catch (...) {
47756       {
47757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47758       };
47759     }
47760   }
47761
47762   jresult = (void *)result;
47763   return jresult;
47764 }
47765
47766
47767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsY(void * jarg1) {
47768   void * jresult ;
47769   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47770   Dali::NinePatchImage::StretchRanges *result = 0 ;
47771
47772   arg1 = (Dali::NinePatchImage *)jarg1;
47773   {
47774     try {
47775       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsY();
47776     } catch (std::out_of_range& e) {
47777       {
47778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47779       };
47780     } catch (std::exception& e) {
47781       {
47782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47783       };
47784     } catch (Dali::DaliException e) {
47785       {
47786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47787       };
47788     } catch (...) {
47789       {
47790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47791       };
47792     }
47793   }
47794
47795   jresult = (void *)result;
47796   return jresult;
47797 }
47798
47799
47800 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetChildRectangle(void * jarg1) {
47801   void * jresult ;
47802   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47803   Dali::Rect< int > result;
47804
47805   arg1 = (Dali::NinePatchImage *)jarg1;
47806   {
47807     try {
47808       result = (arg1)->GetChildRectangle();
47809     } catch (std::out_of_range& e) {
47810       {
47811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47812       };
47813     } catch (std::exception& e) {
47814       {
47815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47816       };
47817     } catch (Dali::DaliException e) {
47818       {
47819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47820       };
47821     } catch (...) {
47822       {
47823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47824       };
47825     }
47826   }
47827
47828   jresult = new Dali::Rect< int >((const Dali::Rect< int > &)result);
47829   return jresult;
47830 }
47831
47832
47833 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_CreateCroppedBufferImage(void * jarg1) {
47834   void * jresult ;
47835   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47836   Dali::BufferImage result;
47837
47838   arg1 = (Dali::NinePatchImage *)jarg1;
47839   {
47840     try {
47841       result = (arg1)->CreateCroppedBufferImage();
47842     } catch (std::out_of_range& e) {
47843       {
47844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47845       };
47846     } catch (std::exception& e) {
47847       {
47848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47849       };
47850     } catch (Dali::DaliException e) {
47851       {
47852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47853       };
47854     } catch (...) {
47855       {
47856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47857       };
47858     }
47859   }
47860
47861   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
47862   return jresult;
47863 }
47864
47865
47866 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NinePatchImage_IsNinePatchUrl(char * jarg1) {
47867   unsigned int jresult ;
47868   std::string *arg1 = 0 ;
47869   bool result;
47870
47871   if (!jarg1) {
47872     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
47873     return 0;
47874   }
47875   std::string arg1_str(jarg1);
47876   arg1 = &arg1_str;
47877   {
47878     try {
47879       result = (bool)Dali::NinePatchImage::IsNinePatchUrl((std::string const &)*arg1);
47880     } catch (std::out_of_range& e) {
47881       {
47882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47883       };
47884     } catch (std::exception& e) {
47885       {
47886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47887       };
47888     } catch (Dali::DaliException e) {
47889       {
47890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47891       };
47892     } catch (...) {
47893       {
47894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47895       };
47896     }
47897   }
47898
47899   jresult = result;
47900
47901   //argout typemap for const std::string&
47902
47903   return jresult;
47904 }
47905
47906
47907 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TYPE_get() {
47908   int jresult ;
47909   int result;
47910
47911   result = (int)Dali::CameraActor::Property::TYPE;
47912   jresult = (int)result;
47913   return jresult;
47914 }
47915
47916
47917 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MODE_get() {
47918   int jresult ;
47919   int result;
47920
47921   result = (int)Dali::CameraActor::Property::PROJECTION_MODE;
47922   jresult = (int)result;
47923   return jresult;
47924 }
47925
47926
47927 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FIELD_OF_VIEW_get() {
47928   int jresult ;
47929   int result;
47930
47931   result = (int)Dali::CameraActor::Property::FIELD_OF_VIEW;
47932   jresult = (int)result;
47933   return jresult;
47934 }
47935
47936
47937 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_ASPECT_RATIO_get() {
47938   int jresult ;
47939   int result;
47940
47941   result = (int)Dali::CameraActor::Property::ASPECT_RATIO;
47942   jresult = (int)result;
47943   return jresult;
47944 }
47945
47946
47947 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_NEAR_PLANE_DISTANCE_get() {
47948   int jresult ;
47949   int result;
47950
47951   result = (int)Dali::CameraActor::Property::NEAR_PLANE_DISTANCE;
47952   jresult = (int)result;
47953   return jresult;
47954 }
47955
47956
47957 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FAR_PLANE_DISTANCE_get() {
47958   int jresult ;
47959   int result;
47960
47961   result = (int)Dali::CameraActor::Property::FAR_PLANE_DISTANCE;
47962   jresult = (int)result;
47963   return jresult;
47964 }
47965
47966
47967 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_LEFT_PLANE_DISTANCE_get() {
47968   int jresult ;
47969   int result;
47970
47971   result = (int)Dali::CameraActor::Property::LEFT_PLANE_DISTANCE;
47972   jresult = (int)result;
47973   return jresult;
47974 }
47975
47976
47977 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_RIGHT_PLANE_DISTANCE_get() {
47978   int jresult ;
47979   int result;
47980
47981   result = (int)Dali::CameraActor::Property::RIGHT_PLANE_DISTANCE;
47982   jresult = (int)result;
47983   return jresult;
47984 }
47985
47986
47987 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TOP_PLANE_DISTANCE_get() {
47988   int jresult ;
47989   int result;
47990
47991   result = (int)Dali::CameraActor::Property::TOP_PLANE_DISTANCE;
47992   jresult = (int)result;
47993   return jresult;
47994 }
47995
47996
47997 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_BOTTOM_PLANE_DISTANCE_get() {
47998   int jresult ;
47999   int result;
48000
48001   result = (int)Dali::CameraActor::Property::BOTTOM_PLANE_DISTANCE;
48002   jresult = (int)result;
48003   return jresult;
48004 }
48005
48006
48007 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TARGET_POSITION_get() {
48008   int jresult ;
48009   int result;
48010
48011   result = (int)Dali::CameraActor::Property::TARGET_POSITION;
48012   jresult = (int)result;
48013   return jresult;
48014 }
48015
48016
48017 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MATRIX_get() {
48018   int jresult ;
48019   int result;
48020
48021   result = (int)Dali::CameraActor::Property::PROJECTION_MATRIX;
48022   jresult = (int)result;
48023   return jresult;
48024 }
48025
48026
48027 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_VIEW_MATRIX_get() {
48028   int jresult ;
48029   int result;
48030
48031   result = (int)Dali::CameraActor::Property::VIEW_MATRIX;
48032   jresult = (int)result;
48033   return jresult;
48034 }
48035
48036
48037 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_INVERT_Y_AXIS_get() {
48038   int jresult ;
48039   int result;
48040
48041   result = (int)Dali::CameraActor::Property::INVERT_Y_AXIS;
48042   jresult = (int)result;
48043   return jresult;
48044 }
48045
48046
48047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor_Property() {
48048   void * jresult ;
48049   Dali::CameraActor::Property *result = 0 ;
48050
48051   {
48052     try {
48053       result = (Dali::CameraActor::Property *)new Dali::CameraActor::Property();
48054     } catch (std::out_of_range& e) {
48055       {
48056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48057       };
48058     } catch (std::exception& e) {
48059       {
48060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48061       };
48062     } catch (Dali::DaliException e) {
48063       {
48064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48065       };
48066     } catch (...) {
48067       {
48068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48069       };
48070     }
48071   }
48072
48073   jresult = (void *)result;
48074   return jresult;
48075 }
48076
48077
48078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor_Property(void * jarg1) {
48079   Dali::CameraActor::Property *arg1 = (Dali::CameraActor::Property *) 0 ;
48080
48081   arg1 = (Dali::CameraActor::Property *)jarg1;
48082   {
48083     try {
48084       delete arg1;
48085     } catch (std::out_of_range& e) {
48086       {
48087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48088       };
48089     } catch (std::exception& e) {
48090       {
48091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48092       };
48093     } catch (Dali::DaliException e) {
48094       {
48095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48096       };
48097     } catch (...) {
48098       {
48099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48100       };
48101     }
48102   }
48103
48104 }
48105
48106
48107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_0() {
48108   void * jresult ;
48109   Dali::CameraActor *result = 0 ;
48110
48111   {
48112     try {
48113       result = (Dali::CameraActor *)new Dali::CameraActor();
48114     } catch (std::out_of_range& e) {
48115       {
48116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48117       };
48118     } catch (std::exception& e) {
48119       {
48120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48121       };
48122     } catch (Dali::DaliException e) {
48123       {
48124         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48125       };
48126     } catch (...) {
48127       {
48128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48129       };
48130     }
48131   }
48132
48133   jresult = (void *)result;
48134   return jresult;
48135 }
48136
48137
48138 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_0() {
48139   void * jresult ;
48140   Dali::CameraActor result;
48141
48142   {
48143     try {
48144       result = Dali::CameraActor::New();
48145     } catch (std::out_of_range& e) {
48146       {
48147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48148       };
48149     } catch (std::exception& e) {
48150       {
48151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48152       };
48153     } catch (Dali::DaliException e) {
48154       {
48155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48156       };
48157     } catch (...) {
48158       {
48159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48160       };
48161     }
48162   }
48163
48164   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
48165   return jresult;
48166 }
48167
48168
48169 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_1(void * jarg1) {
48170   void * jresult ;
48171   Dali::Size *arg1 = 0 ;
48172   Dali::CameraActor result;
48173
48174   arg1 = (Dali::Size *)jarg1;
48175   if (!arg1) {
48176     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
48177     return 0;
48178   }
48179   {
48180     try {
48181       result = Dali::CameraActor::New((Dali::Vector2 const &)*arg1);
48182     } catch (std::out_of_range& e) {
48183       {
48184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48185       };
48186     } catch (std::exception& e) {
48187       {
48188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48189       };
48190     } catch (Dali::DaliException e) {
48191       {
48192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48193       };
48194     } catch (...) {
48195       {
48196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48197       };
48198     }
48199   }
48200
48201   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
48202   return jresult;
48203 }
48204
48205
48206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_DownCast(void * jarg1) {
48207   void * jresult ;
48208   Dali::BaseHandle arg1 ;
48209   Dali::BaseHandle *argp1 ;
48210   Dali::CameraActor result;
48211
48212   argp1 = (Dali::BaseHandle *)jarg1;
48213   if (!argp1) {
48214     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
48215     return 0;
48216   }
48217   arg1 = *argp1;
48218   {
48219     try {
48220       result = Dali::CameraActor::DownCast(arg1);
48221     } catch (std::out_of_range& e) {
48222       {
48223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48224       };
48225     } catch (std::exception& e) {
48226       {
48227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48228       };
48229     } catch (Dali::DaliException e) {
48230       {
48231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48232       };
48233     } catch (...) {
48234       {
48235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48236       };
48237     }
48238   }
48239
48240   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
48241   return jresult;
48242 }
48243
48244
48245 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor(void * jarg1) {
48246   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48247
48248   arg1 = (Dali::CameraActor *)jarg1;
48249   {
48250     try {
48251       delete arg1;
48252     } catch (std::out_of_range& e) {
48253       {
48254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48255       };
48256     } catch (std::exception& e) {
48257       {
48258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48259       };
48260     } catch (Dali::DaliException e) {
48261       {
48262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48263       };
48264     } catch (...) {
48265       {
48266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48267       };
48268     }
48269   }
48270
48271 }
48272
48273
48274 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_1(void * jarg1) {
48275   void * jresult ;
48276   Dali::CameraActor *arg1 = 0 ;
48277   Dali::CameraActor *result = 0 ;
48278
48279   arg1 = (Dali::CameraActor *)jarg1;
48280   if (!arg1) {
48281     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
48282     return 0;
48283   }
48284   {
48285     try {
48286       result = (Dali::CameraActor *)new Dali::CameraActor((Dali::CameraActor const &)*arg1);
48287     } catch (std::out_of_range& e) {
48288       {
48289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48290       };
48291     } catch (std::exception& e) {
48292       {
48293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48294       };
48295     } catch (Dali::DaliException e) {
48296       {
48297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48298       };
48299     } catch (...) {
48300       {
48301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48302       };
48303     }
48304   }
48305
48306   jresult = (void *)result;
48307   return jresult;
48308 }
48309
48310
48311 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_Assign(void * jarg1, void * jarg2) {
48312   void * jresult ;
48313   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48314   Dali::CameraActor *arg2 = 0 ;
48315   Dali::CameraActor *result = 0 ;
48316
48317   arg1 = (Dali::CameraActor *)jarg1;
48318   arg2 = (Dali::CameraActor *)jarg2;
48319   if (!arg2) {
48320     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
48321     return 0;
48322   }
48323   {
48324     try {
48325       result = (Dali::CameraActor *) &(arg1)->operator =((Dali::CameraActor const &)*arg2);
48326     } catch (std::out_of_range& e) {
48327       {
48328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48329       };
48330     } catch (std::exception& e) {
48331       {
48332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48333       };
48334     } catch (Dali::DaliException e) {
48335       {
48336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48337       };
48338     } catch (...) {
48339       {
48340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48341       };
48342     }
48343   }
48344
48345   jresult = (void *)result;
48346   return jresult;
48347 }
48348
48349
48350 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetType(void * jarg1, int jarg2) {
48351   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48352   Dali::Camera::Type arg2 ;
48353
48354   arg1 = (Dali::CameraActor *)jarg1;
48355   arg2 = (Dali::Camera::Type)jarg2;
48356   {
48357     try {
48358       (arg1)->SetType(arg2);
48359     } catch (std::out_of_range& e) {
48360       {
48361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48362       };
48363     } catch (std::exception& e) {
48364       {
48365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48366       };
48367     } catch (Dali::DaliException e) {
48368       {
48369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48370       };
48371     } catch (...) {
48372       {
48373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48374       };
48375     }
48376   }
48377
48378 }
48379
48380
48381 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetType(void * jarg1) {
48382   int jresult ;
48383   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48384   Dali::Camera::Type result;
48385
48386   arg1 = (Dali::CameraActor *)jarg1;
48387   {
48388     try {
48389       result = (Dali::Camera::Type)((Dali::CameraActor const *)arg1)->GetType();
48390     } catch (std::out_of_range& e) {
48391       {
48392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48393       };
48394     } catch (std::exception& e) {
48395       {
48396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48397       };
48398     } catch (Dali::DaliException e) {
48399       {
48400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48401       };
48402     } catch (...) {
48403       {
48404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48405       };
48406     }
48407   }
48408
48409   jresult = (int)result;
48410   return jresult;
48411 }
48412
48413
48414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetProjectionMode(void * jarg1, int jarg2) {
48415   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48416   Dali::Camera::ProjectionMode arg2 ;
48417
48418   arg1 = (Dali::CameraActor *)jarg1;
48419   arg2 = (Dali::Camera::ProjectionMode)jarg2;
48420   {
48421     try {
48422       (arg1)->SetProjectionMode(arg2);
48423     } catch (std::out_of_range& e) {
48424       {
48425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48426       };
48427     } catch (std::exception& e) {
48428       {
48429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48430       };
48431     } catch (Dali::DaliException e) {
48432       {
48433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48434       };
48435     } catch (...) {
48436       {
48437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48438       };
48439     }
48440   }
48441
48442 }
48443
48444
48445 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetProjectionMode(void * jarg1) {
48446   int jresult ;
48447   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48448   Dali::Camera::ProjectionMode result;
48449
48450   arg1 = (Dali::CameraActor *)jarg1;
48451   {
48452     try {
48453       result = (Dali::Camera::ProjectionMode)((Dali::CameraActor const *)arg1)->GetProjectionMode();
48454     } catch (std::out_of_range& e) {
48455       {
48456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48457       };
48458     } catch (std::exception& e) {
48459       {
48460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48461       };
48462     } catch (Dali::DaliException e) {
48463       {
48464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48465       };
48466     } catch (...) {
48467       {
48468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48469       };
48470     }
48471   }
48472
48473   jresult = (int)result;
48474   return jresult;
48475 }
48476
48477
48478 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFieldOfView(void * jarg1, float jarg2) {
48479   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48480   float arg2 ;
48481
48482   arg1 = (Dali::CameraActor *)jarg1;
48483   arg2 = (float)jarg2;
48484   {
48485     try {
48486       (arg1)->SetFieldOfView(arg2);
48487     } catch (std::out_of_range& e) {
48488       {
48489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48490       };
48491     } catch (std::exception& e) {
48492       {
48493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48494       };
48495     } catch (Dali::DaliException e) {
48496       {
48497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48498       };
48499     } catch (...) {
48500       {
48501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48502       };
48503     }
48504   }
48505
48506 }
48507
48508
48509 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFieldOfView(void * jarg1) {
48510   float jresult ;
48511   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48512   float result;
48513
48514   arg1 = (Dali::CameraActor *)jarg1;
48515   {
48516     try {
48517       result = (float)(arg1)->GetFieldOfView();
48518     } catch (std::out_of_range& e) {
48519       {
48520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48521       };
48522     } catch (std::exception& e) {
48523       {
48524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48525       };
48526     } catch (Dali::DaliException e) {
48527       {
48528         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48529       };
48530     } catch (...) {
48531       {
48532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48533       };
48534     }
48535   }
48536
48537   jresult = result;
48538   return jresult;
48539 }
48540
48541
48542 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetAspectRatio(void * jarg1, float jarg2) {
48543   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48544   float arg2 ;
48545
48546   arg1 = (Dali::CameraActor *)jarg1;
48547   arg2 = (float)jarg2;
48548   {
48549     try {
48550       (arg1)->SetAspectRatio(arg2);
48551     } catch (std::out_of_range& e) {
48552       {
48553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48554       };
48555     } catch (std::exception& e) {
48556       {
48557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48558       };
48559     } catch (Dali::DaliException e) {
48560       {
48561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48562       };
48563     } catch (...) {
48564       {
48565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48566       };
48567     }
48568   }
48569
48570 }
48571
48572
48573 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetAspectRatio(void * jarg1) {
48574   float jresult ;
48575   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48576   float result;
48577
48578   arg1 = (Dali::CameraActor *)jarg1;
48579   {
48580     try {
48581       result = (float)(arg1)->GetAspectRatio();
48582     } catch (std::out_of_range& e) {
48583       {
48584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48585       };
48586     } catch (std::exception& e) {
48587       {
48588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48589       };
48590     } catch (Dali::DaliException e) {
48591       {
48592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48593       };
48594     } catch (...) {
48595       {
48596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48597       };
48598     }
48599   }
48600
48601   jresult = result;
48602   return jresult;
48603 }
48604
48605
48606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetNearClippingPlane(void * jarg1, float jarg2) {
48607   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48608   float arg2 ;
48609
48610   arg1 = (Dali::CameraActor *)jarg1;
48611   arg2 = (float)jarg2;
48612   {
48613     try {
48614       (arg1)->SetNearClippingPlane(arg2);
48615     } catch (std::out_of_range& e) {
48616       {
48617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48618       };
48619     } catch (std::exception& e) {
48620       {
48621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48622       };
48623     } catch (Dali::DaliException e) {
48624       {
48625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48626       };
48627     } catch (...) {
48628       {
48629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48630       };
48631     }
48632   }
48633
48634 }
48635
48636
48637 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetNearClippingPlane(void * jarg1) {
48638   float jresult ;
48639   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48640   float result;
48641
48642   arg1 = (Dali::CameraActor *)jarg1;
48643   {
48644     try {
48645       result = (float)(arg1)->GetNearClippingPlane();
48646     } catch (std::out_of_range& e) {
48647       {
48648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48649       };
48650     } catch (std::exception& e) {
48651       {
48652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48653       };
48654     } catch (Dali::DaliException e) {
48655       {
48656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48657       };
48658     } catch (...) {
48659       {
48660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48661       };
48662     }
48663   }
48664
48665   jresult = result;
48666   return jresult;
48667 }
48668
48669
48670 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFarClippingPlane(void * jarg1, float jarg2) {
48671   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48672   float arg2 ;
48673
48674   arg1 = (Dali::CameraActor *)jarg1;
48675   arg2 = (float)jarg2;
48676   {
48677     try {
48678       (arg1)->SetFarClippingPlane(arg2);
48679     } catch (std::out_of_range& e) {
48680       {
48681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48682       };
48683     } catch (std::exception& e) {
48684       {
48685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48686       };
48687     } catch (Dali::DaliException e) {
48688       {
48689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48690       };
48691     } catch (...) {
48692       {
48693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48694       };
48695     }
48696   }
48697
48698 }
48699
48700
48701 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFarClippingPlane(void * jarg1) {
48702   float jresult ;
48703   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48704   float result;
48705
48706   arg1 = (Dali::CameraActor *)jarg1;
48707   {
48708     try {
48709       result = (float)(arg1)->GetFarClippingPlane();
48710     } catch (std::out_of_range& e) {
48711       {
48712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48713       };
48714     } catch (std::exception& e) {
48715       {
48716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48717       };
48718     } catch (Dali::DaliException e) {
48719       {
48720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48721       };
48722     } catch (...) {
48723       {
48724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48725       };
48726     }
48727   }
48728
48729   jresult = result;
48730   return jresult;
48731 }
48732
48733
48734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetTargetPosition(void * jarg1, void * jarg2) {
48735   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48736   Dali::Vector3 *arg2 = 0 ;
48737
48738   arg1 = (Dali::CameraActor *)jarg1;
48739   arg2 = (Dali::Vector3 *)jarg2;
48740   if (!arg2) {
48741     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
48742     return ;
48743   }
48744   {
48745     try {
48746       (arg1)->SetTargetPosition((Dali::Vector3 const &)*arg2);
48747     } catch (std::out_of_range& e) {
48748       {
48749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48750       };
48751     } catch (std::exception& e) {
48752       {
48753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48754       };
48755     } catch (Dali::DaliException e) {
48756       {
48757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48758       };
48759     } catch (...) {
48760       {
48761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48762       };
48763     }
48764   }
48765
48766 }
48767
48768
48769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_GetTargetPosition(void * jarg1) {
48770   void * jresult ;
48771   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48772   Dali::Vector3 result;
48773
48774   arg1 = (Dali::CameraActor *)jarg1;
48775   {
48776     try {
48777       result = ((Dali::CameraActor const *)arg1)->GetTargetPosition();
48778     } catch (std::out_of_range& e) {
48779       {
48780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48781       };
48782     } catch (std::exception& e) {
48783       {
48784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48785       };
48786     } catch (Dali::DaliException e) {
48787       {
48788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48789       };
48790     } catch (...) {
48791       {
48792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48793       };
48794     }
48795   }
48796
48797   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
48798   return jresult;
48799 }
48800
48801
48802 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetInvertYAxis(void * jarg1, unsigned int jarg2) {
48803   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48804   bool arg2 ;
48805
48806   arg1 = (Dali::CameraActor *)jarg1;
48807   arg2 = jarg2 ? true : false;
48808   {
48809     try {
48810       (arg1)->SetInvertYAxis(arg2);
48811     } catch (std::out_of_range& e) {
48812       {
48813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48814       };
48815     } catch (std::exception& e) {
48816       {
48817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48818       };
48819     } catch (Dali::DaliException e) {
48820       {
48821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48822       };
48823     } catch (...) {
48824       {
48825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48826       };
48827     }
48828   }
48829
48830 }
48831
48832
48833 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CameraActor_GetInvertYAxis(void * jarg1) {
48834   unsigned int jresult ;
48835   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48836   bool result;
48837
48838   arg1 = (Dali::CameraActor *)jarg1;
48839   {
48840     try {
48841       result = (bool)(arg1)->GetInvertYAxis();
48842     } catch (std::out_of_range& e) {
48843       {
48844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48845       };
48846     } catch (std::exception& e) {
48847       {
48848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48849       };
48850     } catch (Dali::DaliException e) {
48851       {
48852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48853       };
48854     } catch (...) {
48855       {
48856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48857       };
48858     }
48859   }
48860
48861   jresult = result;
48862   return jresult;
48863 }
48864
48865
48866 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetPerspectiveProjection(void * jarg1, void * jarg2) {
48867   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48868   Dali::Size *arg2 = 0 ;
48869
48870   arg1 = (Dali::CameraActor *)jarg1;
48871   arg2 = (Dali::Size *)jarg2;
48872   if (!arg2) {
48873     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
48874     return ;
48875   }
48876   {
48877     try {
48878       (arg1)->SetPerspectiveProjection((Dali::Size const &)*arg2);
48879     } catch (std::out_of_range& e) {
48880       {
48881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48882       };
48883     } catch (std::exception& e) {
48884       {
48885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48886       };
48887     } catch (Dali::DaliException e) {
48888       {
48889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48890       };
48891     } catch (...) {
48892       {
48893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48894       };
48895     }
48896   }
48897
48898 }
48899
48900
48901 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_0(void * jarg1, void * jarg2) {
48902   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48903   Dali::Size *arg2 = 0 ;
48904
48905   arg1 = (Dali::CameraActor *)jarg1;
48906   arg2 = (Dali::Size *)jarg2;
48907   if (!arg2) {
48908     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
48909     return ;
48910   }
48911   {
48912     try {
48913       (arg1)->SetOrthographicProjection((Dali::Size const &)*arg2);
48914     } catch (std::out_of_range& e) {
48915       {
48916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48917       };
48918     } catch (std::exception& e) {
48919       {
48920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48921       };
48922     } catch (Dali::DaliException e) {
48923       {
48924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48925       };
48926     } catch (...) {
48927       {
48928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48929       };
48930     }
48931   }
48932
48933 }
48934
48935
48936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7) {
48937   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48938   float arg2 ;
48939   float arg3 ;
48940   float arg4 ;
48941   float arg5 ;
48942   float arg6 ;
48943   float arg7 ;
48944
48945   arg1 = (Dali::CameraActor *)jarg1;
48946   arg2 = (float)jarg2;
48947   arg3 = (float)jarg3;
48948   arg4 = (float)jarg4;
48949   arg5 = (float)jarg5;
48950   arg6 = (float)jarg6;
48951   arg7 = (float)jarg7;
48952   {
48953     try {
48954       (arg1)->SetOrthographicProjection(arg2,arg3,arg4,arg5,arg6,arg7);
48955     } catch (std::out_of_range& e) {
48956       {
48957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48958       };
48959     } catch (std::exception& e) {
48960       {
48961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48962       };
48963     } catch (Dali::DaliException e) {
48964       {
48965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48966       };
48967     } catch (...) {
48968       {
48969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48970       };
48971     }
48972   }
48973
48974 }
48975
48976
48977 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_0() {
48978   void * jresult ;
48979   std::pair< std::string,Dali::Property::Value > *result = 0 ;
48980
48981   {
48982     try {
48983       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >();
48984     } catch (std::out_of_range& e) {
48985       {
48986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48987       };
48988     } catch (std::exception& e) {
48989       {
48990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48991       };
48992     } catch (Dali::DaliException e) {
48993       {
48994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48995       };
48996     } catch (...) {
48997       {
48998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48999       };
49000     }
49001   }
49002
49003   jresult = (void *)result;
49004   return jresult;
49005 }
49006
49007
49008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_1(char * jarg1, void * jarg2) {
49009   void * jresult ;
49010   std::string arg1 ;
49011   Dali::Property::Value arg2 ;
49012   Dali::Property::Value *argp2 ;
49013   std::pair< std::string,Dali::Property::Value > *result = 0 ;
49014
49015   if (!jarg1) {
49016     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
49017     return 0;
49018   }
49019   (&arg1)->assign(jarg1);
49020   argp2 = (Dali::Property::Value *)jarg2;
49021   if (!argp2) {
49022     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
49023     return 0;
49024   }
49025   arg2 = *argp2;
49026   {
49027     try {
49028       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >(arg1,arg2);
49029     } catch (std::out_of_range& e) {
49030       {
49031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49032       };
49033     } catch (std::exception& e) {
49034       {
49035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49036       };
49037     } catch (Dali::DaliException e) {
49038       {
49039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49040       };
49041     } catch (...) {
49042       {
49043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49044       };
49045     }
49046   }
49047
49048   jresult = (void *)result;
49049   return jresult;
49050 }
49051
49052
49053 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_2(void * jarg1) {
49054   void * jresult ;
49055   std::pair< std::string,Dali::Property::Value > *arg1 = 0 ;
49056   std::pair< std::string,Dali::Property::Value > *result = 0 ;
49057
49058   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49059   if (!arg1) {
49060     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< std::string,Dali::Property::Value > const & type is null", 0);
49061     return 0;
49062   }
49063   {
49064     try {
49065       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);
49066     } catch (std::out_of_range& e) {
49067       {
49068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49069       };
49070     } catch (std::exception& e) {
49071       {
49072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49073       };
49074     } catch (Dali::DaliException e) {
49075       {
49076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49077       };
49078     } catch (...) {
49079       {
49080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49081       };
49082     }
49083   }
49084
49085   jresult = (void *)result;
49086   return jresult;
49087 }
49088
49089
49090 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_first_set(void * jarg1, char * jarg2) {
49091   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49092   std::string *arg2 = 0 ;
49093
49094   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49095   if (!jarg2) {
49096     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
49097     return ;
49098   }
49099   std::string arg2_str(jarg2);
49100   arg2 = &arg2_str;
49101   if (arg1) (arg1)->first = *arg2;
49102
49103   //argout typemap for const std::string&
49104
49105 }
49106
49107
49108 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_StringValuePair_first_get(void * jarg1) {
49109   char * jresult ;
49110   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49111   std::string *result = 0 ;
49112
49113   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49114   result = (std::string *) & ((arg1)->first);
49115   jresult = SWIG_csharp_string_callback(result->c_str());
49116   return jresult;
49117 }
49118
49119
49120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_second_set(void * jarg1, void * jarg2) {
49121   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49122   Dali::Property::Value *arg2 = (Dali::Property::Value *) 0 ;
49123
49124   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49125   arg2 = (Dali::Property::Value *)jarg2;
49126   if (arg1) (arg1)->second = *arg2;
49127 }
49128
49129
49130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StringValuePair_second_get(void * jarg1) {
49131   void * jresult ;
49132   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49133   Dali::Property::Value *result = 0 ;
49134
49135   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49136   result = (Dali::Property::Value *)& ((arg1)->second);
49137   jresult = (void *)result;
49138   return jresult;
49139 }
49140
49141
49142 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StringValuePair(void * jarg1) {
49143   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49144
49145   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49146   {
49147     try {
49148       delete arg1;
49149     } catch (std::out_of_range& e) {
49150       {
49151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49152       };
49153     } catch (std::exception& e) {
49154       {
49155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49156       };
49157     } catch (Dali::DaliException e) {
49158       {
49159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49160       };
49161     } catch (...) {
49162       {
49163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49164       };
49165     }
49166   }
49167
49168 }
49169
49170
49171 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Clear(void * jarg1) {
49172   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49173
49174   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49175   {
49176     try {
49177       (arg1)->clear();
49178     } catch (std::out_of_range& e) {
49179       {
49180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49181       };
49182     } catch (std::exception& e) {
49183       {
49184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49185       };
49186     } catch (Dali::DaliException e) {
49187       {
49188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49189       };
49190     } catch (...) {
49191       {
49192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49193       };
49194     }
49195   }
49196
49197 }
49198
49199
49200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Add(void * jarg1, void * jarg2) {
49201   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49202   Dali::TouchPoint *arg2 = 0 ;
49203
49204   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49205   arg2 = (Dali::TouchPoint *)jarg2;
49206   if (!arg2) {
49207     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49208     return ;
49209   }
49210   {
49211     try {
49212       (arg1)->push_back((Dali::TouchPoint const &)*arg2);
49213     } catch (std::out_of_range& e) {
49214       {
49215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49216       };
49217     } catch (std::exception& e) {
49218       {
49219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49220       };
49221     } catch (Dali::DaliException e) {
49222       {
49223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49224       };
49225     } catch (...) {
49226       {
49227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49228       };
49229     }
49230   }
49231
49232 }
49233
49234
49235 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_size(void * jarg1) {
49236   unsigned long jresult ;
49237   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49238   std::vector< Dali::TouchPoint >::size_type result;
49239
49240   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49241   {
49242     try {
49243       result = ((std::vector< Dali::TouchPoint > const *)arg1)->size();
49244     } catch (std::out_of_range& e) {
49245       {
49246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49247       };
49248     } catch (std::exception& e) {
49249       {
49250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49251       };
49252     } catch (Dali::DaliException e) {
49253       {
49254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49255       };
49256     } catch (...) {
49257       {
49258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49259       };
49260     }
49261   }
49262
49263   jresult = (unsigned long)result;
49264   return jresult;
49265 }
49266
49267
49268 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_capacity(void * jarg1) {
49269   unsigned long jresult ;
49270   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49271   std::vector< Dali::TouchPoint >::size_type result;
49272
49273   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49274   {
49275     try {
49276       result = ((std::vector< Dali::TouchPoint > const *)arg1)->capacity();
49277     } catch (std::out_of_range& e) {
49278       {
49279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49280       };
49281     } catch (std::exception& e) {
49282       {
49283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49284       };
49285     } catch (Dali::DaliException e) {
49286       {
49287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49288       };
49289     } catch (...) {
49290       {
49291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49292       };
49293     }
49294   }
49295
49296   jresult = (unsigned long)result;
49297   return jresult;
49298 }
49299
49300
49301 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_reserve(void * jarg1, unsigned long jarg2) {
49302   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49303   std::vector< Dali::TouchPoint >::size_type arg2 ;
49304
49305   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49306   arg2 = (std::vector< Dali::TouchPoint >::size_type)jarg2;
49307   {
49308     try {
49309       (arg1)->reserve(arg2);
49310     } catch (std::out_of_range& e) {
49311       {
49312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49313       };
49314     } catch (std::exception& e) {
49315       {
49316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49317       };
49318     } catch (Dali::DaliException e) {
49319       {
49320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49321       };
49322     } catch (...) {
49323       {
49324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49325       };
49326     }
49327   }
49328
49329 }
49330
49331
49332 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_0() {
49333   void * jresult ;
49334   std::vector< Dali::TouchPoint > *result = 0 ;
49335
49336   {
49337     try {
49338       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >();
49339     } catch (std::out_of_range& e) {
49340       {
49341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49342       };
49343     } catch (std::exception& e) {
49344       {
49345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49346       };
49347     } catch (Dali::DaliException e) {
49348       {
49349         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49350       };
49351     } catch (...) {
49352       {
49353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49354       };
49355     }
49356   }
49357
49358   jresult = (void *)result;
49359   return jresult;
49360 }
49361
49362
49363 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_1(void * jarg1) {
49364   void * jresult ;
49365   std::vector< Dali::TouchPoint > *arg1 = 0 ;
49366   std::vector< Dali::TouchPoint > *result = 0 ;
49367
49368   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49369   if (!arg1) {
49370     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49371     return 0;
49372   }
49373   {
49374     try {
49375       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >((std::vector< Dali::TouchPoint > const &)*arg1);
49376     } catch (std::out_of_range& e) {
49377       {
49378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49379       };
49380     } catch (std::exception& e) {
49381       {
49382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49383       };
49384     } catch (Dali::DaliException e) {
49385       {
49386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49387       };
49388     } catch (...) {
49389       {
49390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49391       };
49392     }
49393   }
49394
49395   jresult = (void *)result;
49396   return jresult;
49397 }
49398
49399
49400 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_2(int jarg1) {
49401   void * jresult ;
49402   int arg1 ;
49403   std::vector< Dali::TouchPoint > *result = 0 ;
49404
49405   arg1 = (int)jarg1;
49406   {
49407     try {
49408       try {
49409         result = (std::vector< Dali::TouchPoint > *)new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(arg1);
49410       }
49411       catch(std::out_of_range &_e) {
49412         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49413         return 0;
49414       }
49415
49416     } catch (std::out_of_range& e) {
49417       {
49418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49419       };
49420     } catch (std::exception& e) {
49421       {
49422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49423       };
49424     } catch (Dali::DaliException e) {
49425       {
49426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49427       };
49428     } catch (...) {
49429       {
49430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49431       };
49432     }
49433   }
49434
49435   jresult = (void *)result;
49436   return jresult;
49437 }
49438
49439
49440 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitemcopy(void * jarg1, int jarg2) {
49441   void * jresult ;
49442   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49443   int arg2 ;
49444   SwigValueWrapper< Dali::TouchPoint > result;
49445
49446   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49447   arg2 = (int)jarg2;
49448   {
49449     try {
49450       try {
49451         result = std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(arg1,arg2);
49452       }
49453       catch(std::out_of_range &_e) {
49454         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49455         return 0;
49456       }
49457
49458     } catch (std::out_of_range& e) {
49459       {
49460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49461       };
49462     } catch (std::exception& e) {
49463       {
49464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49465       };
49466     } catch (Dali::DaliException e) {
49467       {
49468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49469       };
49470     } catch (...) {
49471       {
49472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49473       };
49474     }
49475   }
49476
49477   jresult = new Dali::TouchPoint((const Dali::TouchPoint &)result);
49478   return jresult;
49479 }
49480
49481
49482 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitem(void * jarg1, int jarg2) {
49483   void * jresult ;
49484   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49485   int arg2 ;
49486   Dali::TouchPoint *result = 0 ;
49487
49488   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49489   arg2 = (int)jarg2;
49490   {
49491     try {
49492       try {
49493         result = (Dali::TouchPoint *) &std_vector_Sl_Dali_TouchPoint_Sg__getitem(arg1,arg2);
49494       }
49495       catch(std::out_of_range &_e) {
49496         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49497         return 0;
49498       }
49499
49500     } catch (std::out_of_range& e) {
49501       {
49502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49503       };
49504     } catch (std::exception& e) {
49505       {
49506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49507       };
49508     } catch (Dali::DaliException e) {
49509       {
49510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49511       };
49512     } catch (...) {
49513       {
49514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49515       };
49516     }
49517   }
49518
49519   jresult = (void *)result;
49520   return jresult;
49521 }
49522
49523
49524 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
49525   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49526   int arg2 ;
49527   Dali::TouchPoint *arg3 = 0 ;
49528
49529   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49530   arg2 = (int)jarg2;
49531   arg3 = (Dali::TouchPoint *)jarg3;
49532   if (!arg3) {
49533     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49534     return ;
49535   }
49536   {
49537     try {
49538       try {
49539         std_vector_Sl_Dali_TouchPoint_Sg__setitem(arg1,arg2,(Dali::TouchPoint const &)*arg3);
49540       }
49541       catch(std::out_of_range &_e) {
49542         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49543         return ;
49544       }
49545
49546     } catch (std::out_of_range& e) {
49547       {
49548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49549       };
49550     } catch (std::exception& e) {
49551       {
49552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49553       };
49554     } catch (Dali::DaliException e) {
49555       {
49556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49557       };
49558     } catch (...) {
49559       {
49560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49561       };
49562     }
49563   }
49564
49565 }
49566
49567
49568 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_AddRange(void * jarg1, void * jarg2) {
49569   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49570   std::vector< Dali::TouchPoint > *arg2 = 0 ;
49571
49572   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49573   arg2 = (std::vector< Dali::TouchPoint > *)jarg2;
49574   if (!arg2) {
49575     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49576     return ;
49577   }
49578   {
49579     try {
49580       std_vector_Sl_Dali_TouchPoint_Sg__AddRange(arg1,(std::vector< Dali::TouchPoint > const &)*arg2);
49581     } catch (std::out_of_range& e) {
49582       {
49583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49584       };
49585     } catch (std::exception& e) {
49586       {
49587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49588       };
49589     } catch (Dali::DaliException e) {
49590       {
49591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49592       };
49593     } catch (...) {
49594       {
49595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49596       };
49597     }
49598   }
49599
49600 }
49601
49602
49603 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
49604   void * jresult ;
49605   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49606   int arg2 ;
49607   int arg3 ;
49608   std::vector< Dali::TouchPoint > *result = 0 ;
49609
49610   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49611   arg2 = (int)jarg2;
49612   arg3 = (int)jarg3;
49613   {
49614     try {
49615       try {
49616         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__GetRange(arg1,arg2,arg3);
49617       }
49618       catch(std::out_of_range &_e) {
49619         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49620         return 0;
49621       }
49622       catch(std::invalid_argument &_e) {
49623         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
49624         return 0;
49625       }
49626
49627     } catch (std::out_of_range& e) {
49628       {
49629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49630       };
49631     } catch (std::exception& e) {
49632       {
49633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49634       };
49635     } catch (Dali::DaliException e) {
49636       {
49637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49638       };
49639     } catch (...) {
49640       {
49641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49642       };
49643     }
49644   }
49645
49646   jresult = (void *)result;
49647   return jresult;
49648 }
49649
49650
49651 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
49652   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49653   int arg2 ;
49654   Dali::TouchPoint *arg3 = 0 ;
49655
49656   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49657   arg2 = (int)jarg2;
49658   arg3 = (Dali::TouchPoint *)jarg3;
49659   if (!arg3) {
49660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49661     return ;
49662   }
49663   {
49664     try {
49665       try {
49666         std_vector_Sl_Dali_TouchPoint_Sg__Insert(arg1,arg2,(Dali::TouchPoint const &)*arg3);
49667       }
49668       catch(std::out_of_range &_e) {
49669         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49670         return ;
49671       }
49672
49673     } catch (std::out_of_range& e) {
49674       {
49675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49676       };
49677     } catch (std::exception& e) {
49678       {
49679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49680       };
49681     } catch (Dali::DaliException e) {
49682       {
49683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49684       };
49685     } catch (...) {
49686       {
49687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49688       };
49689     }
49690   }
49691
49692 }
49693
49694
49695 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
49696   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49697   int arg2 ;
49698   std::vector< Dali::TouchPoint > *arg3 = 0 ;
49699
49700   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49701   arg2 = (int)jarg2;
49702   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
49703   if (!arg3) {
49704     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49705     return ;
49706   }
49707   {
49708     try {
49709       try {
49710         std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
49711       }
49712       catch(std::out_of_range &_e) {
49713         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49714         return ;
49715       }
49716
49717     } catch (std::out_of_range& e) {
49718       {
49719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49720       };
49721     } catch (std::exception& e) {
49722       {
49723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49724       };
49725     } catch (Dali::DaliException e) {
49726       {
49727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49728       };
49729     } catch (...) {
49730       {
49731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49732       };
49733     }
49734   }
49735
49736 }
49737
49738
49739 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveAt(void * jarg1, int jarg2) {
49740   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49741   int arg2 ;
49742
49743   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49744   arg2 = (int)jarg2;
49745   {
49746     try {
49747       try {
49748         std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(arg1,arg2);
49749       }
49750       catch(std::out_of_range &_e) {
49751         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49752         return ;
49753       }
49754
49755     } catch (std::out_of_range& e) {
49756       {
49757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49758       };
49759     } catch (std::exception& e) {
49760       {
49761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49762       };
49763     } catch (Dali::DaliException e) {
49764       {
49765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49766       };
49767     } catch (...) {
49768       {
49769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49770       };
49771     }
49772   }
49773
49774 }
49775
49776
49777 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
49778   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49779   int arg2 ;
49780   int arg3 ;
49781
49782   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49783   arg2 = (int)jarg2;
49784   arg3 = (int)jarg3;
49785   {
49786     try {
49787       try {
49788         std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(arg1,arg2,arg3);
49789       }
49790       catch(std::out_of_range &_e) {
49791         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49792         return ;
49793       }
49794       catch(std::invalid_argument &_e) {
49795         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
49796         return ;
49797       }
49798
49799     } catch (std::out_of_range& e) {
49800       {
49801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49802       };
49803     } catch (std::exception& e) {
49804       {
49805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49806       };
49807     } catch (Dali::DaliException e) {
49808       {
49809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49810       };
49811     } catch (...) {
49812       {
49813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49814       };
49815     }
49816   }
49817
49818 }
49819
49820
49821 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_Repeat(void * jarg1, int jarg2) {
49822   void * jresult ;
49823   Dali::TouchPoint *arg1 = 0 ;
49824   int arg2 ;
49825   std::vector< Dali::TouchPoint > *result = 0 ;
49826
49827   arg1 = (Dali::TouchPoint *)jarg1;
49828   if (!arg1) {
49829     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49830     return 0;
49831   }
49832   arg2 = (int)jarg2;
49833   {
49834     try {
49835       try {
49836         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__Repeat((Dali::TouchPoint const &)*arg1,arg2);
49837       }
49838       catch(std::out_of_range &_e) {
49839         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49840         return 0;
49841       }
49842
49843     } catch (std::out_of_range& e) {
49844       {
49845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49846       };
49847     } catch (std::exception& e) {
49848       {
49849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49850       };
49851     } catch (Dali::DaliException e) {
49852       {
49853         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49854       };
49855     } catch (...) {
49856       {
49857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49858       };
49859     }
49860   }
49861
49862   jresult = (void *)result;
49863   return jresult;
49864 }
49865
49866
49867 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_0(void * jarg1) {
49868   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49869
49870   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49871   {
49872     try {
49873       std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(arg1);
49874     } catch (std::out_of_range& e) {
49875       {
49876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49877       };
49878     } catch (std::exception& e) {
49879       {
49880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49881       };
49882     } catch (Dali::DaliException e) {
49883       {
49884         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49885       };
49886     } catch (...) {
49887       {
49888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49889       };
49890     }
49891   }
49892
49893 }
49894
49895
49896 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
49897   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49898   int arg2 ;
49899   int arg3 ;
49900
49901   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49902   arg2 = (int)jarg2;
49903   arg3 = (int)jarg3;
49904   {
49905     try {
49906       try {
49907         std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
49908       }
49909       catch(std::out_of_range &_e) {
49910         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49911         return ;
49912       }
49913       catch(std::invalid_argument &_e) {
49914         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
49915         return ;
49916       }
49917
49918     } catch (std::out_of_range& e) {
49919       {
49920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49921       };
49922     } catch (std::exception& e) {
49923       {
49924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49925       };
49926     } catch (Dali::DaliException e) {
49927       {
49928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49929       };
49930     } catch (...) {
49931       {
49932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49933       };
49934     }
49935   }
49936
49937 }
49938
49939
49940 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
49941   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49942   int arg2 ;
49943   std::vector< Dali::TouchPoint > *arg3 = 0 ;
49944
49945   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49946   arg2 = (int)jarg2;
49947   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
49948   if (!arg3) {
49949     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49950     return ;
49951   }
49952   {
49953     try {
49954       try {
49955         std_vector_Sl_Dali_TouchPoint_Sg__SetRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
49956       }
49957       catch(std::out_of_range &_e) {
49958         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49959         return ;
49960       }
49961
49962     } catch (std::out_of_range& e) {
49963       {
49964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49965       };
49966     } catch (std::exception& e) {
49967       {
49968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49969       };
49970     } catch (Dali::DaliException e) {
49971       {
49972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49973       };
49974     } catch (...) {
49975       {
49976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49977       };
49978     }
49979   }
49980
49981 }
49982
49983
49984 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPointContainer(void * jarg1) {
49985   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49986
49987   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49988   {
49989     try {
49990       delete arg1;
49991     } catch (std::out_of_range& e) {
49992       {
49993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49994       };
49995     } catch (std::exception& e) {
49996       {
49997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49998       };
49999     } catch (Dali::DaliException e) {
50000       {
50001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50002       };
50003     } catch (...) {
50004       {
50005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50006       };
50007     }
50008   }
50009
50010 }
50011
50012
50013 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_0() {
50014   void * jresult ;
50015   Dali::Rect< int > *result = 0 ;
50016
50017   {
50018     try {
50019       result = (Dali::Rect< int > *)new Dali::Rect< int >();
50020     } catch (std::out_of_range& e) {
50021       {
50022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50023       };
50024     } catch (std::exception& e) {
50025       {
50026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50027       };
50028     } catch (Dali::DaliException e) {
50029       {
50030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50031       };
50032     } catch (...) {
50033       {
50034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50035       };
50036     }
50037   }
50038
50039   jresult = (void *)result;
50040   return jresult;
50041 }
50042
50043
50044 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_1(int jarg1, int jarg2, int jarg3, int jarg4) {
50045   void * jresult ;
50046   int arg1 ;
50047   int arg2 ;
50048   int arg3 ;
50049   int arg4 ;
50050   Dali::Rect< int > *result = 0 ;
50051
50052   arg1 = (int)jarg1;
50053   arg2 = (int)jarg2;
50054   arg3 = (int)jarg3;
50055   arg4 = (int)jarg4;
50056   {
50057     try {
50058       result = (Dali::Rect< int > *)new Dali::Rect< int >(arg1,arg2,arg3,arg4);
50059     } catch (std::out_of_range& e) {
50060       {
50061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50062       };
50063     } catch (std::exception& e) {
50064       {
50065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50066       };
50067     } catch (Dali::DaliException e) {
50068       {
50069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50070       };
50071     } catch (...) {
50072       {
50073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50074       };
50075     }
50076   }
50077
50078   jresult = (void *)result;
50079   return jresult;
50080 }
50081
50082
50083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_2(void * jarg1) {
50084   void * jresult ;
50085   Dali::Rect< int > *arg1 = 0 ;
50086   Dali::Rect< int > *result = 0 ;
50087
50088   arg1 = (Dali::Rect< int > *)jarg1;
50089   if (!arg1) {
50090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
50091     return 0;
50092   }
50093   {
50094     try {
50095       result = (Dali::Rect< int > *)new Dali::Rect< int >((Dali::Rect< int > const &)*arg1);
50096     } catch (std::out_of_range& e) {
50097       {
50098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50099       };
50100     } catch (std::exception& e) {
50101       {
50102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50103       };
50104     } catch (Dali::DaliException e) {
50105       {
50106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50107       };
50108     } catch (...) {
50109       {
50110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50111       };
50112     }
50113   }
50114
50115   jresult = (void *)result;
50116   return jresult;
50117 }
50118
50119
50120 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rectangle_Assign(void * jarg1, void * jarg2) {
50121   void * jresult ;
50122   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50123   Dali::Rect< int > *arg2 = 0 ;
50124   Dali::Rect< int > *result = 0 ;
50125
50126   arg1 = (Dali::Rect< int > *)jarg1;
50127   arg2 = (Dali::Rect< int > *)jarg2;
50128   if (!arg2) {
50129     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
50130     return 0;
50131   }
50132   {
50133     try {
50134       result = (Dali::Rect< int > *) &(arg1)->operator =((Dali::Rect< int > const &)*arg2);
50135     } catch (std::out_of_range& e) {
50136       {
50137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50138       };
50139     } catch (std::exception& e) {
50140       {
50141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50142       };
50143     } catch (Dali::DaliException e) {
50144       {
50145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50146       };
50147     } catch (...) {
50148       {
50149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50150       };
50151     }
50152   }
50153
50154   jresult = (void *)result;
50155   return jresult;
50156 }
50157
50158
50159 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_Set(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
50160   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50161   int arg2 ;
50162   int arg3 ;
50163   int arg4 ;
50164   int arg5 ;
50165
50166   arg1 = (Dali::Rect< int > *)jarg1;
50167   arg2 = (int)jarg2;
50168   arg3 = (int)jarg3;
50169   arg4 = (int)jarg4;
50170   arg5 = (int)jarg5;
50171   {
50172     try {
50173       (arg1)->Set(arg2,arg3,arg4,arg5);
50174     } catch (std::out_of_range& e) {
50175       {
50176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50177       };
50178     } catch (std::exception& e) {
50179       {
50180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50181       };
50182     } catch (Dali::DaliException e) {
50183       {
50184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50185       };
50186     } catch (...) {
50187       {
50188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50189       };
50190     }
50191   }
50192
50193 }
50194
50195
50196 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_IsEmpty(void * jarg1) {
50197   unsigned int jresult ;
50198   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50199   bool result;
50200
50201   arg1 = (Dali::Rect< int > *)jarg1;
50202   {
50203     try {
50204       result = (bool)((Dali::Rect< int > const *)arg1)->IsEmpty();
50205     } catch (std::out_of_range& e) {
50206       {
50207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50208       };
50209     } catch (std::exception& e) {
50210       {
50211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50212       };
50213     } catch (Dali::DaliException e) {
50214       {
50215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50216       };
50217     } catch (...) {
50218       {
50219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50220       };
50221     }
50222   }
50223
50224   jresult = result;
50225   return jresult;
50226 }
50227
50228
50229 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Left(void * jarg1) {
50230   int jresult ;
50231   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50232   int result;
50233
50234   arg1 = (Dali::Rect< int > *)jarg1;
50235   {
50236     try {
50237       result = (int)((Dali::Rect< int > const *)arg1)->Left();
50238     } catch (std::out_of_range& e) {
50239       {
50240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50241       };
50242     } catch (std::exception& e) {
50243       {
50244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50245       };
50246     } catch (Dali::DaliException e) {
50247       {
50248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50249       };
50250     } catch (...) {
50251       {
50252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50253       };
50254     }
50255   }
50256
50257   jresult = result;
50258   return jresult;
50259 }
50260
50261
50262 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Right(void * jarg1) {
50263   int jresult ;
50264   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50265   int result;
50266
50267   arg1 = (Dali::Rect< int > *)jarg1;
50268   {
50269     try {
50270       result = (int)((Dali::Rect< int > const *)arg1)->Right();
50271     } catch (std::out_of_range& e) {
50272       {
50273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50274       };
50275     } catch (std::exception& e) {
50276       {
50277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50278       };
50279     } catch (Dali::DaliException e) {
50280       {
50281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50282       };
50283     } catch (...) {
50284       {
50285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50286       };
50287     }
50288   }
50289
50290   jresult = result;
50291   return jresult;
50292 }
50293
50294
50295 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Top(void * jarg1) {
50296   int jresult ;
50297   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50298   int result;
50299
50300   arg1 = (Dali::Rect< int > *)jarg1;
50301   {
50302     try {
50303       result = (int)((Dali::Rect< int > const *)arg1)->Top();
50304     } catch (std::out_of_range& e) {
50305       {
50306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50307       };
50308     } catch (std::exception& e) {
50309       {
50310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50311       };
50312     } catch (Dali::DaliException e) {
50313       {
50314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50315       };
50316     } catch (...) {
50317       {
50318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50319       };
50320     }
50321   }
50322
50323   jresult = result;
50324   return jresult;
50325 }
50326
50327
50328 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Bottom(void * jarg1) {
50329   int jresult ;
50330   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50331   int result;
50332
50333   arg1 = (Dali::Rect< int > *)jarg1;
50334   {
50335     try {
50336       result = (int)((Dali::Rect< int > const *)arg1)->Bottom();
50337     } catch (std::out_of_range& e) {
50338       {
50339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50340       };
50341     } catch (std::exception& e) {
50342       {
50343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50344       };
50345     } catch (Dali::DaliException e) {
50346       {
50347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50348       };
50349     } catch (...) {
50350       {
50351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50352       };
50353     }
50354   }
50355
50356   jresult = result;
50357   return jresult;
50358 }
50359
50360
50361 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Area(void * jarg1) {
50362   int jresult ;
50363   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50364   int result;
50365
50366   arg1 = (Dali::Rect< int > *)jarg1;
50367   {
50368     try {
50369       result = (int)((Dali::Rect< int > const *)arg1)->Area();
50370     } catch (std::out_of_range& e) {
50371       {
50372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50373       };
50374     } catch (std::exception& e) {
50375       {
50376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50377       };
50378     } catch (Dali::DaliException e) {
50379       {
50380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50381       };
50382     } catch (...) {
50383       {
50384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50385       };
50386     }
50387   }
50388
50389   jresult = result;
50390   return jresult;
50391 }
50392
50393
50394 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Intersects(void * jarg1, void * jarg2) {
50395   unsigned int jresult ;
50396   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50397   Dali::Rect< int > *arg2 = 0 ;
50398   bool result;
50399
50400   arg1 = (Dali::Rect< int > *)jarg1;
50401   arg2 = (Dali::Rect< int > *)jarg2;
50402   if (!arg2) {
50403     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
50404     return 0;
50405   }
50406   {
50407     try {
50408       result = (bool)((Dali::Rect< int > const *)arg1)->Intersects((Dali::Rect< int > const &)*arg2);
50409     } catch (std::out_of_range& e) {
50410       {
50411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50412       };
50413     } catch (std::exception& e) {
50414       {
50415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50416       };
50417     } catch (Dali::DaliException e) {
50418       {
50419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50420       };
50421     } catch (...) {
50422       {
50423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50424       };
50425     }
50426   }
50427
50428   jresult = result;
50429   return jresult;
50430 }
50431
50432
50433 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Contains(void * jarg1, void * jarg2) {
50434   unsigned int jresult ;
50435   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50436   Dali::Rect< int > *arg2 = 0 ;
50437   bool result;
50438
50439   arg1 = (Dali::Rect< int > *)jarg1;
50440   arg2 = (Dali::Rect< int > *)jarg2;
50441   if (!arg2) {
50442     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
50443     return 0;
50444   }
50445   {
50446     try {
50447       result = (bool)((Dali::Rect< int > const *)arg1)->Contains((Dali::Rect< int > const &)*arg2);
50448     } catch (std::out_of_range& e) {
50449       {
50450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50451       };
50452     } catch (std::exception& e) {
50453       {
50454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50455       };
50456     } catch (Dali::DaliException e) {
50457       {
50458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50459       };
50460     } catch (...) {
50461       {
50462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50463       };
50464     }
50465   }
50466
50467   jresult = result;
50468   return jresult;
50469 }
50470
50471
50472 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_x_set(void * jarg1, int jarg2) {
50473   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50474   int arg2 ;
50475
50476   arg1 = (Dali::Rect< int > *)jarg1;
50477   arg2 = (int)jarg2;
50478   if (arg1) (arg1)->x = arg2;
50479 }
50480
50481
50482 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_x_get(void * jarg1) {
50483   int jresult ;
50484   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50485   int result;
50486
50487   arg1 = (Dali::Rect< int > *)jarg1;
50488   result = (int) ((arg1)->x);
50489   jresult = result;
50490   return jresult;
50491 }
50492
50493
50494 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_left_set(void * jarg1, int jarg2) {
50495   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50496   int arg2 ;
50497
50498   arg1 = (Dali::Rect< int > *)jarg1;
50499   arg2 = (int)jarg2;
50500   if (arg1) (arg1)->left = arg2;
50501 }
50502
50503
50504 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_left_get(void * jarg1) {
50505   int jresult ;
50506   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50507   int result;
50508
50509   arg1 = (Dali::Rect< int > *)jarg1;
50510   result = (int) ((arg1)->left);
50511   jresult = result;
50512   return jresult;
50513 }
50514
50515
50516 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_y_set(void * jarg1, int jarg2) {
50517   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50518   int arg2 ;
50519
50520   arg1 = (Dali::Rect< int > *)jarg1;
50521   arg2 = (int)jarg2;
50522   if (arg1) (arg1)->y = arg2;
50523 }
50524
50525
50526 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_y_get(void * jarg1) {
50527   int jresult ;
50528   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50529   int result;
50530
50531   arg1 = (Dali::Rect< int > *)jarg1;
50532   result = (int) ((arg1)->y);
50533   jresult = result;
50534   return jresult;
50535 }
50536
50537
50538 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_right_set(void * jarg1, int jarg2) {
50539   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50540   int arg2 ;
50541
50542   arg1 = (Dali::Rect< int > *)jarg1;
50543   arg2 = (int)jarg2;
50544   if (arg1) (arg1)->right = arg2;
50545 }
50546
50547
50548 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_right_get(void * jarg1) {
50549   int jresult ;
50550   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50551   int result;
50552
50553   arg1 = (Dali::Rect< int > *)jarg1;
50554   result = (int) ((arg1)->right);
50555   jresult = result;
50556   return jresult;
50557 }
50558
50559
50560 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_width_set(void * jarg1, int jarg2) {
50561   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50562   int arg2 ;
50563
50564   arg1 = (Dali::Rect< int > *)jarg1;
50565   arg2 = (int)jarg2;
50566   if (arg1) (arg1)->width = arg2;
50567 }
50568
50569
50570 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_width_get(void * jarg1) {
50571   int jresult ;
50572   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50573   int result;
50574
50575   arg1 = (Dali::Rect< int > *)jarg1;
50576   result = (int) ((arg1)->width);
50577   jresult = result;
50578   return jresult;
50579 }
50580
50581
50582 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_bottom_set(void * jarg1, int jarg2) {
50583   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50584   int arg2 ;
50585
50586   arg1 = (Dali::Rect< int > *)jarg1;
50587   arg2 = (int)jarg2;
50588   if (arg1) (arg1)->bottom = arg2;
50589 }
50590
50591
50592 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_bottom_get(void * jarg1) {
50593   int jresult ;
50594   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50595   int result;
50596
50597   arg1 = (Dali::Rect< int > *)jarg1;
50598   result = (int) ((arg1)->bottom);
50599   jresult = result;
50600   return jresult;
50601 }
50602
50603
50604 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_height_set(void * jarg1, int jarg2) {
50605   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50606   int arg2 ;
50607
50608   arg1 = (Dali::Rect< int > *)jarg1;
50609   arg2 = (int)jarg2;
50610   if (arg1) (arg1)->height = arg2;
50611 }
50612
50613
50614 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_height_get(void * jarg1) {
50615   int jresult ;
50616   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50617   int result;
50618
50619   arg1 = (Dali::Rect< int > *)jarg1;
50620   result = (int) ((arg1)->height);
50621   jresult = result;
50622   return jresult;
50623 }
50624
50625
50626 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_top_set(void * jarg1, int jarg2) {
50627   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50628   int arg2 ;
50629
50630   arg1 = (Dali::Rect< int > *)jarg1;
50631   arg2 = (int)jarg2;
50632   if (arg1) (arg1)->top = arg2;
50633 }
50634
50635
50636 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_top_get(void * jarg1) {
50637   int jresult ;
50638   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50639   int result;
50640
50641   arg1 = (Dali::Rect< int > *)jarg1;
50642   result = (int) ((arg1)->top);
50643   jresult = result;
50644   return jresult;
50645 }
50646
50647
50648 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rectangle(void * jarg1) {
50649   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50650
50651   arg1 = (Dali::Rect< int > *)jarg1;
50652   {
50653     try {
50654       delete arg1;
50655     } catch (std::out_of_range& e) {
50656       {
50657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50658       };
50659     } catch (std::exception& e) {
50660       {
50661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50662       };
50663     } catch (Dali::DaliException e) {
50664       {
50665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50666       };
50667     } catch (...) {
50668       {
50669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50670       };
50671     }
50672   }
50673
50674 }
50675
50676
50677 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_0() {
50678   void * jresult ;
50679   Dali::Rect< float > *result = 0 ;
50680
50681   {
50682     try {
50683       result = (Dali::Rect< float > *)new Dali::Rect< float >();
50684     } catch (std::out_of_range& e) {
50685       {
50686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50687       };
50688     } catch (std::exception& e) {
50689       {
50690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50691       };
50692     } catch (Dali::DaliException e) {
50693       {
50694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50695       };
50696     } catch (...) {
50697       {
50698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50699       };
50700     }
50701   }
50702
50703   jresult = (void *)result;
50704   return jresult;
50705 }
50706
50707
50708 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
50709   void * jresult ;
50710   float arg1 ;
50711   float arg2 ;
50712   float arg3 ;
50713   float arg4 ;
50714   Dali::Rect< float > *result = 0 ;
50715
50716   arg1 = (float)jarg1;
50717   arg2 = (float)jarg2;
50718   arg3 = (float)jarg4;
50719   arg4 = (float)jarg3;
50720   {
50721     try {
50722       result = (Dali::Rect< float > *)new Dali::Rect< float >(arg1,arg2,arg3,arg4);
50723     } catch (std::out_of_range& e) {
50724       {
50725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50726       };
50727     } catch (std::exception& e) {
50728       {
50729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50730       };
50731     } catch (Dali::DaliException e) {
50732       {
50733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50734       };
50735     } catch (...) {
50736       {
50737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50738       };
50739     }
50740   }
50741
50742   jresult = (void *)result;
50743   return jresult;
50744 }
50745
50746
50747 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_2(void * jarg1) {
50748   void * jresult ;
50749   Dali::Rect< float > *arg1 = 0 ;
50750   Dali::Rect< float > *result = 0 ;
50751
50752   arg1 = (Dali::Rect< float > *)jarg1;
50753   if (!arg1) {
50754     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
50755     return 0;
50756   }
50757   {
50758     try {
50759       result = (Dali::Rect< float > *)new Dali::Rect< float >((Dali::Rect< float > const &)*arg1);
50760     } catch (std::out_of_range& e) {
50761       {
50762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50763       };
50764     } catch (std::exception& e) {
50765       {
50766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50767       };
50768     } catch (Dali::DaliException e) {
50769       {
50770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50771       };
50772     } catch (...) {
50773       {
50774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50775       };
50776     }
50777   }
50778
50779   jresult = (void *)result;
50780   return jresult;
50781 }
50782
50783
50784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PaddingType_Assign(void * jarg1, void * jarg2) {
50785   void * jresult ;
50786   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50787   Dali::Rect< float > *arg2 = 0 ;
50788   Dali::Rect< float > *result = 0 ;
50789
50790   arg1 = (Dali::Rect< float > *)jarg1;
50791   arg2 = (Dali::Rect< float > *)jarg2;
50792   if (!arg2) {
50793     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
50794     return 0;
50795   }
50796   {
50797     try {
50798       result = (Dali::Rect< float > *) &(arg1)->operator =((Dali::Rect< float > const &)*arg2);
50799     } catch (std::out_of_range& e) {
50800       {
50801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50802       };
50803     } catch (std::exception& e) {
50804       {
50805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50806       };
50807     } catch (Dali::DaliException e) {
50808       {
50809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50810       };
50811     } catch (...) {
50812       {
50813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50814       };
50815     }
50816   }
50817
50818   jresult = (void *)result;
50819   return jresult;
50820 }
50821
50822
50823 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_Set(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
50824   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50825   float arg2 ;
50826   float arg3 ;
50827   float arg4 ;
50828   float arg5 ;
50829
50830   arg1 = (Dali::Rect< float > *)jarg1;
50831   arg2 = (float)jarg2;
50832   arg3 = (float)jarg3;
50833   arg4 = (float)jarg5;
50834   arg5 = (float)jarg4;
50835   {
50836     try {
50837       (arg1)->Set(arg2,arg3,arg4,arg5);
50838     } catch (std::out_of_range& e) {
50839       {
50840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50841       };
50842     } catch (std::exception& e) {
50843       {
50844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50845       };
50846     } catch (Dali::DaliException e) {
50847       {
50848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50849       };
50850     } catch (...) {
50851       {
50852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50853       };
50854     }
50855   }
50856
50857 }
50858
50859
50860 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_left_set(void * jarg1, float jarg2) {
50861   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50862   float arg2 ;
50863
50864   arg1 = (Dali::Rect< float > *)jarg1;
50865   arg2 = (float)jarg2;
50866   if (arg1) (arg1)->left = arg2;
50867 }
50868
50869
50870 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_left_get(void * jarg1) {
50871   float jresult ;
50872   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50873   float result;
50874
50875   arg1 = (Dali::Rect< float > *)jarg1;
50876   result = (float) ((arg1)->left);
50877   jresult = result;
50878   return jresult;
50879 }
50880
50881
50882 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_start_set(void * jarg1, float jarg2) {
50883   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50884   float arg2 ;
50885
50886   arg1 = (Dali::Rect< float > *)jarg1;
50887   arg2 = (float)jarg2;
50888   if (arg1) (arg1)->left = arg2;
50889 }
50890
50891
50892 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_start_get(void * jarg1) {
50893   float jresult ;
50894   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50895   float result;
50896
50897   arg1 = (Dali::Rect< float > *)jarg1;
50898   result = (float) ((arg1)->left);
50899   jresult = result;
50900   return jresult;
50901 }
50902
50903
50904 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_right_set(void * jarg1, float jarg2) {
50905   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50906   float arg2 ;
50907
50908   arg1 = (Dali::Rect< float > *)jarg1;
50909   arg2 = (float)jarg2;
50910   if (arg1) (arg1)->right = arg2;
50911 }
50912
50913
50914 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_right_get(void * jarg1) {
50915   float jresult ;
50916   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50917   float result;
50918
50919   arg1 = (Dali::Rect< float > *)jarg1;
50920   result = (float) ((arg1)->right);
50921   jresult = result;
50922   return jresult;
50923 }
50924
50925
50926 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_end_set(void * jarg1, float jarg2) {
50927   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50928   float arg2 ;
50929
50930   arg1 = (Dali::Rect< float > *)jarg1;
50931   arg2 = (float)jarg2;
50932   if (arg1) (arg1)->right = arg2;
50933 }
50934
50935
50936 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_end_get(void * jarg1) {
50937   float jresult ;
50938   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50939   float result;
50940
50941   arg1 = (Dali::Rect< float > *)jarg1;
50942   result = (float) ((arg1)->right);
50943   jresult = result;
50944   return jresult;
50945 }
50946
50947
50948 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_bottom_set(void * jarg1, float jarg2) {
50949   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50950   float arg2 ;
50951
50952   arg1 = (Dali::Rect< float > *)jarg1;
50953   arg2 = (float)jarg2;
50954   if (arg1) (arg1)->bottom = arg2;
50955 }
50956
50957
50958 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_bottom_get(void * jarg1) {
50959   float jresult ;
50960   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50961   float result;
50962
50963   arg1 = (Dali::Rect< float > *)jarg1;
50964   result = (float) ((arg1)->bottom);
50965   jresult = result;
50966   return jresult;
50967 }
50968
50969
50970 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_top_set(void * jarg1, float jarg2) {
50971   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50972   float arg2 ;
50973
50974   arg1 = (Dali::Rect< float > *)jarg1;
50975   arg2 = (float)jarg2;
50976   if (arg1) (arg1)->top = arg2;
50977 }
50978
50979
50980 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_top_get(void * jarg1) {
50981   float jresult ;
50982   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50983   float result;
50984
50985   arg1 = (Dali::Rect< float > *)jarg1;
50986   result = (float) ((arg1)->top);
50987   jresult = result;
50988   return jresult;
50989 }
50990
50991
50992 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PaddingType(void * jarg1) {
50993   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50994
50995   arg1 = (Dali::Rect< float > *)jarg1;
50996   {
50997     try {
50998       delete arg1;
50999     } catch (std::out_of_range& e) {
51000       {
51001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51002       };
51003     } catch (std::exception& e) {
51004       {
51005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51006       };
51007     } catch (Dali::DaliException e) {
51008       {
51009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51010       };
51011     } catch (...) {
51012       {
51013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51014       };
51015     }
51016   }
51017
51018 }
51019
51020
51021 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorInteger_BaseType_get() {
51022   int jresult ;
51023   int result;
51024
51025   result = (int)Dali::Vector< int >::BaseType;
51026   jresult = (int)result;
51027   return jresult;
51028 }
51029
51030
51031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_0() {
51032   void * jresult ;
51033   Dali::Vector< int > *result = 0 ;
51034
51035   {
51036     try {
51037       result = (Dali::Vector< int > *)new Dali::Vector< int >();
51038     } catch (std::out_of_range& e) {
51039       {
51040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51041       };
51042     } catch (std::exception& e) {
51043       {
51044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51045       };
51046     } catch (Dali::DaliException e) {
51047       {
51048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51049       };
51050     } catch (...) {
51051       {
51052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51053       };
51054     }
51055   }
51056
51057   jresult = (void *)result;
51058   return jresult;
51059 }
51060
51061
51062 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorInteger(void * jarg1) {
51063   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51064
51065   arg1 = (Dali::Vector< int > *)jarg1;
51066   {
51067     try {
51068       delete arg1;
51069     } catch (std::out_of_range& e) {
51070       {
51071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51072       };
51073     } catch (std::exception& e) {
51074       {
51075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51076       };
51077     } catch (Dali::DaliException e) {
51078       {
51079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51080       };
51081     } catch (...) {
51082       {
51083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51084       };
51085     }
51086   }
51087
51088 }
51089
51090
51091 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_1(void * jarg1) {
51092   void * jresult ;
51093   Dali::Vector< int > *arg1 = 0 ;
51094   Dali::Vector< int > *result = 0 ;
51095
51096   arg1 = (Dali::Vector< int > *)jarg1;
51097   if (!arg1) {
51098     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
51099     return 0;
51100   }
51101   {
51102     try {
51103       result = (Dali::Vector< int > *)new Dali::Vector< int >((Dali::Vector< int > const &)*arg1);
51104     } catch (std::out_of_range& e) {
51105       {
51106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51107       };
51108     } catch (std::exception& e) {
51109       {
51110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51111       };
51112     } catch (Dali::DaliException e) {
51113       {
51114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51115       };
51116     } catch (...) {
51117       {
51118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51119       };
51120     }
51121   }
51122
51123   jresult = (void *)result;
51124   return jresult;
51125 }
51126
51127
51128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Assign(void * jarg1, void * jarg2) {
51129   void * jresult ;
51130   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51131   Dali::Vector< int > *arg2 = 0 ;
51132   Dali::Vector< int > *result = 0 ;
51133
51134   arg1 = (Dali::Vector< int > *)jarg1;
51135   arg2 = (Dali::Vector< int > *)jarg2;
51136   if (!arg2) {
51137     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
51138     return 0;
51139   }
51140   {
51141     try {
51142       result = (Dali::Vector< int > *) &(arg1)->operator =((Dali::Vector< int > const &)*arg2);
51143     } catch (std::out_of_range& e) {
51144       {
51145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51146       };
51147     } catch (std::exception& e) {
51148       {
51149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51150       };
51151     } catch (Dali::DaliException e) {
51152       {
51153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51154       };
51155     } catch (...) {
51156       {
51157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51158       };
51159     }
51160   }
51161
51162   jresult = (void *)result;
51163   return jresult;
51164 }
51165
51166
51167 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Begin(void * jarg1) {
51168   void * jresult ;
51169   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51170   Dali::Vector< int >::Iterator result;
51171
51172   arg1 = (Dali::Vector< int > *)jarg1;
51173   {
51174     try {
51175       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->Begin();
51176     } catch (std::out_of_range& e) {
51177       {
51178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51179       };
51180     } catch (std::exception& e) {
51181       {
51182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51183       };
51184     } catch (Dali::DaliException e) {
51185       {
51186         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51187       };
51188     } catch (...) {
51189       {
51190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51191       };
51192     }
51193   }
51194
51195   jresult = (void *)result;
51196   return jresult;
51197 }
51198
51199
51200 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_End(void * jarg1) {
51201   void * jresult ;
51202   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51203   Dali::Vector< int >::Iterator result;
51204
51205   arg1 = (Dali::Vector< int > *)jarg1;
51206   {
51207     try {
51208       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->End();
51209     } catch (std::out_of_range& e) {
51210       {
51211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51212       };
51213     } catch (std::exception& e) {
51214       {
51215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51216       };
51217     } catch (Dali::DaliException e) {
51218       {
51219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51220       };
51221     } catch (...) {
51222       {
51223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51224       };
51225     }
51226   }
51227
51228   jresult = (void *)result;
51229   return jresult;
51230 }
51231
51232
51233 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
51234   void * jresult ;
51235   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51236   Dali::Vector< int >::SizeType arg2 ;
51237   Dali::Vector< int >::ItemType *result = 0 ;
51238
51239   arg1 = (Dali::Vector< int > *)jarg1;
51240   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51241   {
51242     try {
51243       result = (Dali::Vector< int >::ItemType *) &(arg1)->operator [](arg2);
51244     } catch (std::out_of_range& e) {
51245       {
51246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51247       };
51248     } catch (std::exception& e) {
51249       {
51250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51251       };
51252     } catch (Dali::DaliException e) {
51253       {
51254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51255       };
51256     } catch (...) {
51257       {
51258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51259       };
51260     }
51261   }
51262
51263   jresult = (void *)result;
51264   return jresult;
51265 }
51266
51267
51268 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_PushBack(void * jarg1, int jarg2) {
51269   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51270   Dali::Vector< int >::ItemType *arg2 = 0 ;
51271   Dali::Vector< int >::ItemType temp2 ;
51272
51273   arg1 = (Dali::Vector< int > *)jarg1;
51274   temp2 = (Dali::Vector< int >::ItemType)jarg2;
51275   arg2 = &temp2;
51276   {
51277     try {
51278       (arg1)->PushBack((Dali::Vector< int >::ItemType const &)*arg2);
51279     } catch (std::out_of_range& e) {
51280       {
51281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51282       };
51283     } catch (std::exception& e) {
51284       {
51285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51286       };
51287     } catch (Dali::DaliException e) {
51288       {
51289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51290       };
51291     } catch (...) {
51292       {
51293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51294       };
51295     }
51296   }
51297
51298 }
51299
51300
51301 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_0(void * jarg1, void * jarg2, int jarg3) {
51302   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51303   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51304   Dali::Vector< int >::ItemType *arg3 = 0 ;
51305   Dali::Vector< int >::ItemType temp3 ;
51306
51307   arg1 = (Dali::Vector< int > *)jarg1;
51308   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51309   temp3 = (Dali::Vector< int >::ItemType)jarg3;
51310   arg3 = &temp3;
51311   {
51312     try {
51313       (arg1)->Insert(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
51314     } catch (std::out_of_range& e) {
51315       {
51316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51317       };
51318     } catch (std::exception& e) {
51319       {
51320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51321       };
51322     } catch (Dali::DaliException e) {
51323       {
51324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51325       };
51326     } catch (...) {
51327       {
51328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51329       };
51330     }
51331   }
51332
51333 }
51334
51335
51336 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
51337   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51338   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51339   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
51340   Dali::Vector< int >::Iterator arg4 = (Dali::Vector< int >::Iterator) 0 ;
51341
51342   arg1 = (Dali::Vector< int > *)jarg1;
51343   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51344   arg3 = (Dali::Vector< int >::Iterator)jarg3;
51345   arg4 = (Dali::Vector< int >::Iterator)jarg4;
51346   {
51347     try {
51348       (arg1)->Insert(arg2,arg3,arg4);
51349     } catch (std::out_of_range& e) {
51350       {
51351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51352       };
51353     } catch (std::exception& e) {
51354       {
51355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51356       };
51357     } catch (Dali::DaliException e) {
51358       {
51359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51360       };
51361     } catch (...) {
51362       {
51363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51364       };
51365     }
51366   }
51367
51368 }
51369
51370
51371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Reserve(void * jarg1, unsigned long jarg2) {
51372   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51373   Dali::Vector< int >::SizeType arg2 ;
51374
51375   arg1 = (Dali::Vector< int > *)jarg1;
51376   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51377   {
51378     try {
51379       (arg1)->Reserve(arg2);
51380     } catch (std::out_of_range& e) {
51381       {
51382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51383       };
51384     } catch (std::exception& e) {
51385       {
51386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51387       };
51388     } catch (Dali::DaliException e) {
51389       {
51390         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51391       };
51392     } catch (...) {
51393       {
51394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51395       };
51396     }
51397   }
51398
51399 }
51400
51401
51402 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
51403   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51404   Dali::Vector< int >::SizeType arg2 ;
51405
51406   arg1 = (Dali::Vector< int > *)jarg1;
51407   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51408   {
51409     try {
51410       (arg1)->Resize(arg2);
51411     } catch (std::out_of_range& e) {
51412       {
51413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51414       };
51415     } catch (std::exception& e) {
51416       {
51417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51418       };
51419     } catch (Dali::DaliException e) {
51420       {
51421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51422       };
51423     } catch (...) {
51424       {
51425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51426       };
51427     }
51428   }
51429
51430 }
51431
51432
51433 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_1(void * jarg1, unsigned long jarg2, int jarg3) {
51434   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51435   Dali::Vector< int >::SizeType arg2 ;
51436   Dali::Vector< int >::ItemType *arg3 = 0 ;
51437   Dali::Vector< int >::ItemType temp3 ;
51438
51439   arg1 = (Dali::Vector< int > *)jarg1;
51440   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51441   temp3 = (Dali::Vector< int >::ItemType)jarg3;
51442   arg3 = &temp3;
51443   {
51444     try {
51445       (arg1)->Resize(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
51446     } catch (std::out_of_range& e) {
51447       {
51448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51449       };
51450     } catch (std::exception& e) {
51451       {
51452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51453       };
51454     } catch (Dali::DaliException e) {
51455       {
51456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51457       };
51458     } catch (...) {
51459       {
51460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51461       };
51462     }
51463   }
51464
51465 }
51466
51467
51468 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_0(void * jarg1, void * jarg2) {
51469   void * jresult ;
51470   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51471   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51472   Dali::Vector< int >::Iterator result;
51473
51474   arg1 = (Dali::Vector< int > *)jarg1;
51475   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51476   {
51477     try {
51478       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2);
51479     } catch (std::out_of_range& e) {
51480       {
51481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51482       };
51483     } catch (std::exception& e) {
51484       {
51485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51486       };
51487     } catch (Dali::DaliException e) {
51488       {
51489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51490       };
51491     } catch (...) {
51492       {
51493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51494       };
51495     }
51496   }
51497
51498   jresult = (void *)result;
51499   return jresult;
51500 }
51501
51502
51503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
51504   void * jresult ;
51505   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51506   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51507   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
51508   Dali::Vector< int >::Iterator result;
51509
51510   arg1 = (Dali::Vector< int > *)jarg1;
51511   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51512   arg3 = (Dali::Vector< int >::Iterator)jarg3;
51513   {
51514     try {
51515       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2,arg3);
51516     } catch (std::out_of_range& e) {
51517       {
51518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51519       };
51520     } catch (std::exception& e) {
51521       {
51522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51523       };
51524     } catch (Dali::DaliException e) {
51525       {
51526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51527       };
51528     } catch (...) {
51529       {
51530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51531       };
51532     }
51533   }
51534
51535   jresult = (void *)result;
51536   return jresult;
51537 }
51538
51539
51540 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Remove(void * jarg1, void * jarg2) {
51541   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51542   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51543
51544   arg1 = (Dali::Vector< int > *)jarg1;
51545   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51546   {
51547     try {
51548       (arg1)->Remove(arg2);
51549     } catch (std::out_of_range& e) {
51550       {
51551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51552       };
51553     } catch (std::exception& e) {
51554       {
51555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51556       };
51557     } catch (Dali::DaliException e) {
51558       {
51559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51560       };
51561     } catch (...) {
51562       {
51563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51564       };
51565     }
51566   }
51567
51568 }
51569
51570
51571 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Swap(void * jarg1, void * jarg2) {
51572   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51573   Dali::Vector< int > *arg2 = 0 ;
51574
51575   arg1 = (Dali::Vector< int > *)jarg1;
51576   arg2 = (Dali::Vector< int > *)jarg2;
51577   if (!arg2) {
51578     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > & type is null", 0);
51579     return ;
51580   }
51581   {
51582     try {
51583       (arg1)->Swap(*arg2);
51584     } catch (std::out_of_range& e) {
51585       {
51586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51587       };
51588     } catch (std::exception& e) {
51589       {
51590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51591       };
51592     } catch (Dali::DaliException e) {
51593       {
51594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51595       };
51596     } catch (...) {
51597       {
51598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51599       };
51600     }
51601   }
51602
51603 }
51604
51605
51606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Clear(void * jarg1) {
51607   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51608
51609   arg1 = (Dali::Vector< int > *)jarg1;
51610   {
51611     try {
51612       (arg1)->Clear();
51613     } catch (std::out_of_range& e) {
51614       {
51615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51616       };
51617     } catch (std::exception& e) {
51618       {
51619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51620       };
51621     } catch (Dali::DaliException e) {
51622       {
51623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51624       };
51625     } catch (...) {
51626       {
51627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51628       };
51629     }
51630   }
51631
51632 }
51633
51634
51635 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Release(void * jarg1) {
51636   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51637
51638   arg1 = (Dali::Vector< int > *)jarg1;
51639   {
51640     try {
51641       (arg1)->Release();
51642     } catch (std::out_of_range& e) {
51643       {
51644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51645       };
51646     } catch (std::exception& e) {
51647       {
51648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51649       };
51650     } catch (Dali::DaliException e) {
51651       {
51652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51653       };
51654     } catch (...) {
51655       {
51656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51657       };
51658     }
51659   }
51660
51661 }
51662
51663
51664 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorFloat_BaseType_get() {
51665   int jresult ;
51666   int result;
51667
51668   result = (int)Dali::Vector< float >::BaseType;
51669   jresult = (int)result;
51670   return jresult;
51671 }
51672
51673
51674 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_0() {
51675   void * jresult ;
51676   Dali::Vector< float > *result = 0 ;
51677
51678   {
51679     try {
51680       result = (Dali::Vector< float > *)new Dali::Vector< float >();
51681     } catch (std::out_of_range& e) {
51682       {
51683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51684       };
51685     } catch (std::exception& e) {
51686       {
51687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51688       };
51689     } catch (Dali::DaliException e) {
51690       {
51691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51692       };
51693     } catch (...) {
51694       {
51695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51696       };
51697     }
51698   }
51699
51700   jresult = (void *)result;
51701   return jresult;
51702 }
51703
51704
51705 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorFloat(void * jarg1) {
51706   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51707
51708   arg1 = (Dali::Vector< float > *)jarg1;
51709   {
51710     try {
51711       delete arg1;
51712     } catch (std::out_of_range& e) {
51713       {
51714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51715       };
51716     } catch (std::exception& e) {
51717       {
51718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51719       };
51720     } catch (Dali::DaliException e) {
51721       {
51722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51723       };
51724     } catch (...) {
51725       {
51726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51727       };
51728     }
51729   }
51730
51731 }
51732
51733
51734 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_1(void * jarg1) {
51735   void * jresult ;
51736   Dali::Vector< float > *arg1 = 0 ;
51737   Dali::Vector< float > *result = 0 ;
51738
51739   arg1 = (Dali::Vector< float > *)jarg1;
51740   if (!arg1) {
51741     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
51742     return 0;
51743   }
51744   {
51745     try {
51746       result = (Dali::Vector< float > *)new Dali::Vector< float >((Dali::Vector< float > const &)*arg1);
51747     } catch (std::out_of_range& e) {
51748       {
51749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51750       };
51751     } catch (std::exception& e) {
51752       {
51753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51754       };
51755     } catch (Dali::DaliException e) {
51756       {
51757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51758       };
51759     } catch (...) {
51760       {
51761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51762       };
51763     }
51764   }
51765
51766   jresult = (void *)result;
51767   return jresult;
51768 }
51769
51770
51771 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Assign(void * jarg1, void * jarg2) {
51772   void * jresult ;
51773   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51774   Dali::Vector< float > *arg2 = 0 ;
51775   Dali::Vector< float > *result = 0 ;
51776
51777   arg1 = (Dali::Vector< float > *)jarg1;
51778   arg2 = (Dali::Vector< float > *)jarg2;
51779   if (!arg2) {
51780     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
51781     return 0;
51782   }
51783   {
51784     try {
51785       result = (Dali::Vector< float > *) &(arg1)->operator =((Dali::Vector< float > const &)*arg2);
51786     } catch (std::out_of_range& e) {
51787       {
51788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51789       };
51790     } catch (std::exception& e) {
51791       {
51792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51793       };
51794     } catch (Dali::DaliException e) {
51795       {
51796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51797       };
51798     } catch (...) {
51799       {
51800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51801       };
51802     }
51803   }
51804
51805   jresult = (void *)result;
51806   return jresult;
51807 }
51808
51809
51810 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Begin(void * jarg1) {
51811   void * jresult ;
51812   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51813   Dali::Vector< float >::Iterator result;
51814
51815   arg1 = (Dali::Vector< float > *)jarg1;
51816   {
51817     try {
51818       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->Begin();
51819     } catch (std::out_of_range& e) {
51820       {
51821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51822       };
51823     } catch (std::exception& e) {
51824       {
51825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51826       };
51827     } catch (Dali::DaliException e) {
51828       {
51829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51830       };
51831     } catch (...) {
51832       {
51833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51834       };
51835     }
51836   }
51837
51838   jresult = (void *)result;
51839   return jresult;
51840 }
51841
51842
51843 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_End(void * jarg1) {
51844   void * jresult ;
51845   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51846   Dali::Vector< float >::Iterator result;
51847
51848   arg1 = (Dali::Vector< float > *)jarg1;
51849   {
51850     try {
51851       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->End();
51852     } catch (std::out_of_range& e) {
51853       {
51854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51855       };
51856     } catch (std::exception& e) {
51857       {
51858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51859       };
51860     } catch (Dali::DaliException e) {
51861       {
51862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51863       };
51864     } catch (...) {
51865       {
51866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51867       };
51868     }
51869   }
51870
51871   jresult = (void *)result;
51872   return jresult;
51873 }
51874
51875
51876 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
51877   void * jresult ;
51878   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51879   Dali::Vector< float >::SizeType arg2 ;
51880   Dali::Vector< float >::ItemType *result = 0 ;
51881
51882   arg1 = (Dali::Vector< float > *)jarg1;
51883   arg2 = (Dali::Vector< float >::SizeType)jarg2;
51884   {
51885     try {
51886       result = (Dali::Vector< float >::ItemType *) &(arg1)->operator [](arg2);
51887     } catch (std::out_of_range& e) {
51888       {
51889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51890       };
51891     } catch (std::exception& e) {
51892       {
51893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51894       };
51895     } catch (Dali::DaliException e) {
51896       {
51897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51898       };
51899     } catch (...) {
51900       {
51901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51902       };
51903     }
51904   }
51905
51906   jresult = (void *)result;
51907   return jresult;
51908 }
51909
51910
51911 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_PushBack(void * jarg1, float jarg2) {
51912   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51913   Dali::Vector< float >::ItemType *arg2 = 0 ;
51914   Dali::Vector< float >::ItemType temp2 ;
51915
51916   arg1 = (Dali::Vector< float > *)jarg1;
51917   temp2 = (Dali::Vector< float >::ItemType)jarg2;
51918   arg2 = &temp2;
51919   {
51920     try {
51921       (arg1)->PushBack((Dali::Vector< float >::ItemType const &)*arg2);
51922     } catch (std::out_of_range& e) {
51923       {
51924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51925       };
51926     } catch (std::exception& e) {
51927       {
51928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51929       };
51930     } catch (Dali::DaliException e) {
51931       {
51932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51933       };
51934     } catch (...) {
51935       {
51936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51937       };
51938     }
51939   }
51940
51941 }
51942
51943
51944 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_0(void * jarg1, void * jarg2, float jarg3) {
51945   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51946   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
51947   Dali::Vector< float >::ItemType *arg3 = 0 ;
51948   Dali::Vector< float >::ItemType temp3 ;
51949
51950   arg1 = (Dali::Vector< float > *)jarg1;
51951   arg2 = (Dali::Vector< float >::Iterator)jarg2;
51952   temp3 = (Dali::Vector< float >::ItemType)jarg3;
51953   arg3 = &temp3;
51954   {
51955     try {
51956       (arg1)->Insert(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
51957     } catch (std::out_of_range& e) {
51958       {
51959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51960       };
51961     } catch (std::exception& e) {
51962       {
51963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51964       };
51965     } catch (Dali::DaliException e) {
51966       {
51967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51968       };
51969     } catch (...) {
51970       {
51971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51972       };
51973     }
51974   }
51975
51976 }
51977
51978
51979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
51980   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51981   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
51982   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
51983   Dali::Vector< float >::Iterator arg4 = (Dali::Vector< float >::Iterator) 0 ;
51984
51985   arg1 = (Dali::Vector< float > *)jarg1;
51986   arg2 = (Dali::Vector< float >::Iterator)jarg2;
51987   arg3 = (Dali::Vector< float >::Iterator)jarg3;
51988   arg4 = (Dali::Vector< float >::Iterator)jarg4;
51989   {
51990     try {
51991       (arg1)->Insert(arg2,arg3,arg4);
51992     } catch (std::out_of_range& e) {
51993       {
51994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51995       };
51996     } catch (std::exception& e) {
51997       {
51998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51999       };
52000     } catch (Dali::DaliException e) {
52001       {
52002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52003       };
52004     } catch (...) {
52005       {
52006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52007       };
52008     }
52009   }
52010
52011 }
52012
52013
52014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Reserve(void * jarg1, unsigned long jarg2) {
52015   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52016   Dali::Vector< float >::SizeType arg2 ;
52017
52018   arg1 = (Dali::Vector< float > *)jarg1;
52019   arg2 = (Dali::Vector< float >::SizeType)jarg2;
52020   {
52021     try {
52022       (arg1)->Reserve(arg2);
52023     } catch (std::out_of_range& e) {
52024       {
52025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52026       };
52027     } catch (std::exception& e) {
52028       {
52029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52030       };
52031     } catch (Dali::DaliException e) {
52032       {
52033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52034       };
52035     } catch (...) {
52036       {
52037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52038       };
52039     }
52040   }
52041
52042 }
52043
52044 //// ========================= end of part 2 =============================
52045
52046 //// ========================== start part 3 ===============================
52047
52048
52049 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
52050   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52051   Dali::Vector< float >::SizeType arg2 ;
52052
52053   arg1 = (Dali::Vector< float > *)jarg1;
52054   arg2 = (Dali::Vector< float >::SizeType)jarg2;
52055   {
52056     try {
52057       (arg1)->Resize(arg2);
52058     } catch (std::out_of_range& e) {
52059       {
52060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52061       };
52062     } catch (std::exception& e) {
52063       {
52064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52065       };
52066     } catch (Dali::DaliException e) {
52067       {
52068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52069       };
52070     } catch (...) {
52071       {
52072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52073       };
52074     }
52075   }
52076
52077 }
52078
52079
52080 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_1(void * jarg1, unsigned long jarg2, float jarg3) {
52081   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52082   Dali::Vector< float >::SizeType arg2 ;
52083   Dali::Vector< float >::ItemType *arg3 = 0 ;
52084   Dali::Vector< float >::ItemType temp3 ;
52085
52086   arg1 = (Dali::Vector< float > *)jarg1;
52087   arg2 = (Dali::Vector< float >::SizeType)jarg2;
52088   temp3 = (Dali::Vector< float >::ItemType)jarg3;
52089   arg3 = &temp3;
52090   {
52091     try {
52092       (arg1)->Resize(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
52093     } catch (std::out_of_range& e) {
52094       {
52095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52096       };
52097     } catch (std::exception& e) {
52098       {
52099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52100       };
52101     } catch (Dali::DaliException e) {
52102       {
52103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52104       };
52105     } catch (...) {
52106       {
52107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52108       };
52109     }
52110   }
52111
52112 }
52113
52114
52115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_0(void * jarg1, void * jarg2) {
52116   void * jresult ;
52117   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52118   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
52119   Dali::Vector< float >::Iterator result;
52120
52121   arg1 = (Dali::Vector< float > *)jarg1;
52122   arg2 = (Dali::Vector< float >::Iterator)jarg2;
52123   {
52124     try {
52125       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2);
52126     } catch (std::out_of_range& e) {
52127       {
52128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52129       };
52130     } catch (std::exception& e) {
52131       {
52132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52133       };
52134     } catch (Dali::DaliException e) {
52135       {
52136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52137       };
52138     } catch (...) {
52139       {
52140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52141       };
52142     }
52143   }
52144
52145   jresult = (void *)result;
52146   return jresult;
52147 }
52148
52149
52150 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
52151   void * jresult ;
52152   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52153   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
52154   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
52155   Dali::Vector< float >::Iterator result;
52156
52157   arg1 = (Dali::Vector< float > *)jarg1;
52158   arg2 = (Dali::Vector< float >::Iterator)jarg2;
52159   arg3 = (Dali::Vector< float >::Iterator)jarg3;
52160   {
52161     try {
52162       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2,arg3);
52163     } catch (std::out_of_range& e) {
52164       {
52165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52166       };
52167     } catch (std::exception& e) {
52168       {
52169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52170       };
52171     } catch (Dali::DaliException e) {
52172       {
52173         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52174       };
52175     } catch (...) {
52176       {
52177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52178       };
52179     }
52180   }
52181
52182   jresult = (void *)result;
52183   return jresult;
52184 }
52185
52186
52187 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Remove(void * jarg1, void * jarg2) {
52188   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52189   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
52190
52191   arg1 = (Dali::Vector< float > *)jarg1;
52192   arg2 = (Dali::Vector< float >::Iterator)jarg2;
52193   {
52194     try {
52195       (arg1)->Remove(arg2);
52196     } catch (std::out_of_range& e) {
52197       {
52198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52199       };
52200     } catch (std::exception& e) {
52201       {
52202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52203       };
52204     } catch (Dali::DaliException e) {
52205       {
52206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52207       };
52208     } catch (...) {
52209       {
52210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52211       };
52212     }
52213   }
52214
52215 }
52216
52217
52218 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Swap(void * jarg1, void * jarg2) {
52219   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52220   Dali::Vector< float > *arg2 = 0 ;
52221
52222   arg1 = (Dali::Vector< float > *)jarg1;
52223   arg2 = (Dali::Vector< float > *)jarg2;
52224   if (!arg2) {
52225     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > & type is null", 0);
52226     return ;
52227   }
52228   {
52229     try {
52230       (arg1)->Swap(*arg2);
52231     } catch (std::out_of_range& e) {
52232       {
52233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52234       };
52235     } catch (std::exception& e) {
52236       {
52237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52238       };
52239     } catch (Dali::DaliException e) {
52240       {
52241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52242       };
52243     } catch (...) {
52244       {
52245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52246       };
52247     }
52248   }
52249
52250 }
52251
52252
52253 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Clear(void * jarg1) {
52254   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52255
52256   arg1 = (Dali::Vector< float > *)jarg1;
52257   {
52258     try {
52259       (arg1)->Clear();
52260     } catch (std::out_of_range& e) {
52261       {
52262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52263       };
52264     } catch (std::exception& e) {
52265       {
52266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52267       };
52268     } catch (Dali::DaliException e) {
52269       {
52270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52271       };
52272     } catch (...) {
52273       {
52274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52275       };
52276     }
52277   }
52278
52279 }
52280
52281
52282 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Release(void * jarg1) {
52283   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52284
52285   arg1 = (Dali::Vector< float > *)jarg1;
52286   {
52287     try {
52288       (arg1)->Release();
52289     } catch (std::out_of_range& e) {
52290       {
52291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52292       };
52293     } catch (std::exception& e) {
52294       {
52295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52296       };
52297     } catch (Dali::DaliException e) {
52298       {
52299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52300       };
52301     } catch (...) {
52302       {
52303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52304       };
52305     }
52306   }
52307
52308 }
52309
52310
52311 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_BaseType_get() {
52312   int jresult ;
52313   int result;
52314
52315   result = (int)Dali::Vector< unsigned char >::BaseType;
52316   jresult = (int)result;
52317   return jresult;
52318 }
52319
52320
52321 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_0() {
52322   void * jresult ;
52323   Dali::Vector< unsigned char > *result = 0 ;
52324
52325   {
52326     try {
52327       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >();
52328     } catch (std::out_of_range& e) {
52329       {
52330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52331       };
52332     } catch (std::exception& e) {
52333       {
52334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52335       };
52336     } catch (Dali::DaliException e) {
52337       {
52338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52339       };
52340     } catch (...) {
52341       {
52342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52343       };
52344     }
52345   }
52346
52347   jresult = (void *)result;
52348   return jresult;
52349 }
52350
52351
52352 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUnsignedChar(void * jarg1) {
52353   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52354
52355   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52356   {
52357     try {
52358       delete arg1;
52359     } catch (std::out_of_range& e) {
52360       {
52361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52362       };
52363     } catch (std::exception& e) {
52364       {
52365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52366       };
52367     } catch (Dali::DaliException e) {
52368       {
52369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52370       };
52371     } catch (...) {
52372       {
52373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52374       };
52375     }
52376   }
52377
52378 }
52379
52380
52381 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_1(void * jarg1) {
52382   void * jresult ;
52383   Dali::Vector< unsigned char > *arg1 = 0 ;
52384   Dali::Vector< unsigned char > *result = 0 ;
52385
52386   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52387   if (!arg1) {
52388     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
52389     return 0;
52390   }
52391   {
52392     try {
52393       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >((Dali::Vector< unsigned char > const &)*arg1);
52394     } catch (std::out_of_range& e) {
52395       {
52396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52397       };
52398     } catch (std::exception& e) {
52399       {
52400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52401       };
52402     } catch (Dali::DaliException e) {
52403       {
52404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52405       };
52406     } catch (...) {
52407       {
52408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52409       };
52410     }
52411   }
52412
52413   jresult = (void *)result;
52414   return jresult;
52415 }
52416
52417
52418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Assign(void * jarg1, void * jarg2) {
52419   void * jresult ;
52420   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52421   Dali::Vector< unsigned char > *arg2 = 0 ;
52422   Dali::Vector< unsigned char > *result = 0 ;
52423
52424   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52425   arg2 = (Dali::Vector< unsigned char > *)jarg2;
52426   if (!arg2) {
52427     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
52428     return 0;
52429   }
52430   {
52431     try {
52432       result = (Dali::Vector< unsigned char > *) &(arg1)->operator =((Dali::Vector< unsigned char > const &)*arg2);
52433     } catch (std::out_of_range& e) {
52434       {
52435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52436       };
52437     } catch (std::exception& e) {
52438       {
52439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52440       };
52441     } catch (Dali::DaliException e) {
52442       {
52443         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52444       };
52445     } catch (...) {
52446       {
52447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52448       };
52449     }
52450   }
52451
52452   jresult = (void *)result;
52453   return jresult;
52454 }
52455
52456
52457 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Begin(void * jarg1) {
52458   void * jresult ;
52459   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52460   Dali::Vector< unsigned char >::Iterator result;
52461
52462   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52463   {
52464     try {
52465       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->Begin();
52466     } catch (std::out_of_range& e) {
52467       {
52468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52469       };
52470     } catch (std::exception& e) {
52471       {
52472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52473       };
52474     } catch (Dali::DaliException e) {
52475       {
52476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52477       };
52478     } catch (...) {
52479       {
52480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52481       };
52482     }
52483   }
52484
52485   jresult = (void *)result;
52486   return jresult;
52487 }
52488
52489
52490 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_End(void * jarg1) {
52491   void * jresult ;
52492   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52493   Dali::Vector< unsigned char >::Iterator result;
52494
52495   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52496   {
52497     try {
52498       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->End();
52499     } catch (std::out_of_range& e) {
52500       {
52501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52502       };
52503     } catch (std::exception& e) {
52504       {
52505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52506       };
52507     } catch (Dali::DaliException e) {
52508       {
52509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52510       };
52511     } catch (...) {
52512       {
52513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52514       };
52515     }
52516   }
52517
52518   jresult = (void *)result;
52519   return jresult;
52520 }
52521
52522
52523 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
52524   void * jresult ;
52525   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52526   Dali::Vector< unsigned char >::SizeType arg2 ;
52527   Dali::Vector< unsigned char >::ItemType *result = 0 ;
52528
52529   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52530   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52531   {
52532     try {
52533       result = (Dali::Vector< unsigned char >::ItemType *) &(arg1)->operator [](arg2);
52534     } catch (std::out_of_range& e) {
52535       {
52536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52537       };
52538     } catch (std::exception& e) {
52539       {
52540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52541       };
52542     } catch (Dali::DaliException e) {
52543       {
52544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52545       };
52546     } catch (...) {
52547       {
52548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52549       };
52550     }
52551   }
52552
52553   jresult = (void *)result;
52554   return jresult;
52555 }
52556
52557
52558 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_PushBack(void * jarg1, unsigned char jarg2) {
52559   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52560   Dali::Vector< unsigned char >::ItemType *arg2 = 0 ;
52561   Dali::Vector< unsigned char >::ItemType temp2 ;
52562
52563   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52564   temp2 = (Dali::Vector< unsigned char >::ItemType)jarg2;
52565   arg2 = &temp2;
52566   {
52567     try {
52568       (arg1)->PushBack((Dali::Vector< unsigned char >::ItemType const &)*arg2);
52569     } catch (std::out_of_range& e) {
52570       {
52571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52572       };
52573     } catch (std::exception& e) {
52574       {
52575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52576       };
52577     } catch (Dali::DaliException e) {
52578       {
52579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52580       };
52581     } catch (...) {
52582       {
52583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52584       };
52585     }
52586   }
52587
52588 }
52589
52590
52591 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_0(void * jarg1, unsigned char* jarg2, unsigned char jarg3) {
52592   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52593   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52594   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
52595   Dali::Vector< unsigned char >::ItemType temp3 ;
52596
52597   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52598   arg2 = jarg2;
52599   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
52600   arg3 = &temp3;
52601   {
52602     try {
52603       (arg1)->Insert(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
52604     } catch (std::out_of_range& e) {
52605       {
52606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52607       };
52608     } catch (std::exception& e) {
52609       {
52610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52611       };
52612     } catch (Dali::DaliException e) {
52613       {
52614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52615       };
52616     } catch (...) {
52617       {
52618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52619       };
52620     }
52621   }
52622
52623
52624
52625 }
52626
52627
52628 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3, void * jarg4) {
52629   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52630   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52631   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52632   Dali::Vector< unsigned char >::Iterator arg4 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52633
52634   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52635   arg2 = jarg2;
52636   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
52637   arg4 = (Dali::Vector< unsigned char >::Iterator)jarg4;
52638   {
52639     try {
52640       (arg1)->Insert(arg2,arg3,arg4);
52641     } catch (std::out_of_range& e) {
52642       {
52643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52644       };
52645     } catch (std::exception& e) {
52646       {
52647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52648       };
52649     } catch (Dali::DaliException e) {
52650       {
52651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52652       };
52653     } catch (...) {
52654       {
52655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52656       };
52657     }
52658   }
52659
52660
52661
52662 }
52663
52664
52665 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Reserve(void * jarg1, unsigned long jarg2) {
52666   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52667   Dali::Vector< unsigned char >::SizeType arg2 ;
52668
52669   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52670   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52671   {
52672     try {
52673       (arg1)->Reserve(arg2);
52674     } catch (std::out_of_range& e) {
52675       {
52676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52677       };
52678     } catch (std::exception& e) {
52679       {
52680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52681       };
52682     } catch (Dali::DaliException e) {
52683       {
52684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52685       };
52686     } catch (...) {
52687       {
52688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52689       };
52690     }
52691   }
52692
52693 }
52694
52695
52696 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
52697   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52698   Dali::Vector< unsigned char >::SizeType arg2 ;
52699
52700   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52701   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52702   {
52703     try {
52704       (arg1)->Resize(arg2);
52705     } catch (std::out_of_range& e) {
52706       {
52707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52708       };
52709     } catch (std::exception& e) {
52710       {
52711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52712       };
52713     } catch (Dali::DaliException e) {
52714       {
52715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52716       };
52717     } catch (...) {
52718       {
52719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52720       };
52721     }
52722   }
52723
52724 }
52725
52726
52727 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_1(void * jarg1, unsigned long jarg2, unsigned char jarg3) {
52728   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52729   Dali::Vector< unsigned char >::SizeType arg2 ;
52730   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
52731   Dali::Vector< unsigned char >::ItemType temp3 ;
52732
52733   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52734   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52735   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
52736   arg3 = &temp3;
52737   {
52738     try {
52739       (arg1)->Resize(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
52740     } catch (std::out_of_range& e) {
52741       {
52742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52743       };
52744     } catch (std::exception& e) {
52745       {
52746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52747       };
52748     } catch (Dali::DaliException e) {
52749       {
52750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52751       };
52752     } catch (...) {
52753       {
52754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52755       };
52756     }
52757   }
52758
52759 }
52760
52761
52762 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_0(void * jarg1, unsigned char* jarg2) {
52763   void * jresult ;
52764   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52765   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52766   Dali::Vector< unsigned char >::Iterator result;
52767
52768   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52769   arg2 = jarg2;
52770   {
52771     try {
52772       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2);
52773     } catch (std::out_of_range& e) {
52774       {
52775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52776       };
52777     } catch (std::exception& e) {
52778       {
52779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52780       };
52781     } catch (Dali::DaliException e) {
52782       {
52783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52784       };
52785     } catch (...) {
52786       {
52787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52788       };
52789     }
52790   }
52791
52792   jresult = (void *)result;
52793
52794
52795   return jresult;
52796 }
52797
52798
52799 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3) {
52800   void * jresult ;
52801   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52802   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52803   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52804   Dali::Vector< unsigned char >::Iterator result;
52805
52806   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52807   arg2 = jarg2;
52808   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
52809   {
52810     try {
52811       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2,arg3);
52812     } catch (std::out_of_range& e) {
52813       {
52814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52815       };
52816     } catch (std::exception& e) {
52817       {
52818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52819       };
52820     } catch (Dali::DaliException e) {
52821       {
52822         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52823       };
52824     } catch (...) {
52825       {
52826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52827       };
52828     }
52829   }
52830
52831   jresult = (void *)result;
52832
52833
52834   return jresult;
52835 }
52836
52837
52838 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Remove(void * jarg1, unsigned char* jarg2) {
52839   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52840   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52841
52842   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52843   arg2 = jarg2;
52844   {
52845     try {
52846       (arg1)->Remove(arg2);
52847     } catch (std::out_of_range& e) {
52848       {
52849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52850       };
52851     } catch (std::exception& e) {
52852       {
52853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52854       };
52855     } catch (Dali::DaliException e) {
52856       {
52857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52858       };
52859     } catch (...) {
52860       {
52861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52862       };
52863     }
52864   }
52865
52866
52867
52868 }
52869
52870
52871 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Swap(void * jarg1, void * jarg2) {
52872   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52873   Dali::Vector< unsigned char > *arg2 = 0 ;
52874
52875   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52876   arg2 = (Dali::Vector< unsigned char > *)jarg2;
52877   if (!arg2) {
52878     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > & type is null", 0);
52879     return ;
52880   }
52881   {
52882     try {
52883       (arg1)->Swap(*arg2);
52884     } catch (std::out_of_range& e) {
52885       {
52886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52887       };
52888     } catch (std::exception& e) {
52889       {
52890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52891       };
52892     } catch (Dali::DaliException e) {
52893       {
52894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52895       };
52896     } catch (...) {
52897       {
52898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52899       };
52900     }
52901   }
52902
52903 }
52904
52905
52906 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Clear(void * jarg1) {
52907   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52908
52909   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52910   {
52911     try {
52912       (arg1)->Clear();
52913     } catch (std::out_of_range& e) {
52914       {
52915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52916       };
52917     } catch (std::exception& e) {
52918       {
52919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52920       };
52921     } catch (Dali::DaliException e) {
52922       {
52923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52924       };
52925     } catch (...) {
52926       {
52927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52928       };
52929     }
52930   }
52931
52932 }
52933
52934
52935 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Release(void * jarg1) {
52936   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52937
52938   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52939   {
52940     try {
52941       (arg1)->Release();
52942     } catch (std::out_of_range& e) {
52943       {
52944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52945       };
52946     } catch (std::exception& e) {
52947       {
52948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52949       };
52950     } catch (Dali::DaliException e) {
52951       {
52952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52953       };
52954     } catch (...) {
52955       {
52956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52957       };
52958     }
52959   }
52960
52961 }
52962
52963
52964 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUint16Pair_BaseType_get() {
52965   int jresult ;
52966   int result;
52967
52968   result = (int)Dali::Vector< Dali::Uint16Pair >::BaseType;
52969   jresult = (int)result;
52970   return jresult;
52971 }
52972
52973
52974 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_0() {
52975   void * jresult ;
52976   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
52977
52978   {
52979     try {
52980       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >();
52981     } catch (std::out_of_range& e) {
52982       {
52983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52984       };
52985     } catch (std::exception& e) {
52986       {
52987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52988       };
52989     } catch (Dali::DaliException e) {
52990       {
52991         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52992       };
52993     } catch (...) {
52994       {
52995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52996       };
52997     }
52998   }
52999
53000   jresult = (void *)result;
53001   return jresult;
53002 }
53003
53004
53005 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUint16Pair(void * jarg1) {
53006   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53007
53008   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53009   {
53010     try {
53011       delete arg1;
53012     } catch (std::out_of_range& e) {
53013       {
53014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53015       };
53016     } catch (std::exception& e) {
53017       {
53018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53019       };
53020     } catch (Dali::DaliException e) {
53021       {
53022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53023       };
53024     } catch (...) {
53025       {
53026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53027       };
53028     }
53029   }
53030
53031 }
53032
53033
53034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_1(void * jarg1) {
53035   void * jresult ;
53036   Dali::Vector< Dali::Uint16Pair > *arg1 = 0 ;
53037   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
53038
53039   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53040   if (!arg1) {
53041     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
53042     return 0;
53043   }
53044   {
53045     try {
53046       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >((Dali::Vector< Dali::Uint16Pair > const &)*arg1);
53047     } catch (std::out_of_range& e) {
53048       {
53049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53050       };
53051     } catch (std::exception& e) {
53052       {
53053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53054       };
53055     } catch (Dali::DaliException e) {
53056       {
53057         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53058       };
53059     } catch (...) {
53060       {
53061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53062       };
53063     }
53064   }
53065
53066   jresult = (void *)result;
53067   return jresult;
53068 }
53069
53070
53071 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Assign(void * jarg1, void * jarg2) {
53072   void * jresult ;
53073   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53074   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
53075   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
53076
53077   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53078   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
53079   if (!arg2) {
53080     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
53081     return 0;
53082   }
53083   {
53084     try {
53085       result = (Dali::Vector< Dali::Uint16Pair > *) &(arg1)->operator =((Dali::Vector< Dali::Uint16Pair > const &)*arg2);
53086     } catch (std::out_of_range& e) {
53087       {
53088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53089       };
53090     } catch (std::exception& e) {
53091       {
53092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53093       };
53094     } catch (Dali::DaliException e) {
53095       {
53096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53097       };
53098     } catch (...) {
53099       {
53100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53101       };
53102     }
53103   }
53104
53105   jresult = (void *)result;
53106   return jresult;
53107 }
53108
53109
53110 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Begin(void * jarg1) {
53111   void * jresult ;
53112   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53113   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53114
53115   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53116   {
53117     try {
53118       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->Begin();
53119     } catch (std::out_of_range& e) {
53120       {
53121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53122       };
53123     } catch (std::exception& e) {
53124       {
53125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53126       };
53127     } catch (Dali::DaliException e) {
53128       {
53129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53130       };
53131     } catch (...) {
53132       {
53133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53134       };
53135     }
53136   }
53137
53138   jresult = (void *)result;
53139   return jresult;
53140 }
53141
53142
53143 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_End(void * jarg1) {
53144   void * jresult ;
53145   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53146   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53147
53148   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53149   {
53150     try {
53151       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->End();
53152     } catch (std::out_of_range& e) {
53153       {
53154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53155       };
53156     } catch (std::exception& e) {
53157       {
53158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53159       };
53160     } catch (Dali::DaliException e) {
53161       {
53162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53163       };
53164     } catch (...) {
53165       {
53166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53167       };
53168     }
53169   }
53170
53171   jresult = (void *)result;
53172   return jresult;
53173 }
53174
53175
53176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
53177   void * jresult ;
53178   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53179   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53180   Dali::Vector< Dali::Uint16Pair >::ItemType *result = 0 ;
53181
53182   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53183   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53184   {
53185     try {
53186       result = (Dali::Vector< Dali::Uint16Pair >::ItemType *) &(arg1)->operator [](arg2);
53187     } catch (std::out_of_range& e) {
53188       {
53189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53190       };
53191     } catch (std::exception& e) {
53192       {
53193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53194       };
53195     } catch (Dali::DaliException e) {
53196       {
53197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53198       };
53199     } catch (...) {
53200       {
53201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53202       };
53203     }
53204   }
53205
53206   jresult = (void *)result;
53207   return jresult;
53208 }
53209
53210
53211 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_PushBack(void * jarg1, void * jarg2) {
53212   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53213   Dali::Vector< Dali::Uint16Pair >::ItemType *arg2 = 0 ;
53214
53215   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53216   arg2 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg2;
53217   if (!arg2) {
53218     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
53219     return ;
53220   }
53221   {
53222     try {
53223       (arg1)->PushBack((Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg2);
53224     } catch (std::out_of_range& e) {
53225       {
53226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53227       };
53228     } catch (std::exception& e) {
53229       {
53230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53231       };
53232     } catch (Dali::DaliException e) {
53233       {
53234         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53235       };
53236     } catch (...) {
53237       {
53238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53239       };
53240     }
53241   }
53242
53243 }
53244
53245
53246 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
53247   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53248   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53249   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
53250
53251   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53252   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53253   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
53254   if (!arg3) {
53255     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
53256     return ;
53257   }
53258   {
53259     try {
53260       (arg1)->Insert(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
53261     } catch (std::out_of_range& e) {
53262       {
53263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53264       };
53265     } catch (std::exception& e) {
53266       {
53267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53268       };
53269     } catch (Dali::DaliException e) {
53270       {
53271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53272       };
53273     } catch (...) {
53274       {
53275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53276       };
53277     }
53278   }
53279
53280 }
53281
53282
53283 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
53284   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53285   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53286   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53287   Dali::Vector< Dali::Uint16Pair >::Iterator arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53288
53289   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53290   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53291   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
53292   arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg4;
53293   {
53294     try {
53295       (arg1)->Insert(arg2,arg3,arg4);
53296     } catch (std::out_of_range& e) {
53297       {
53298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53299       };
53300     } catch (std::exception& e) {
53301       {
53302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53303       };
53304     } catch (Dali::DaliException e) {
53305       {
53306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53307       };
53308     } catch (...) {
53309       {
53310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53311       };
53312     }
53313   }
53314
53315 }
53316
53317
53318 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Reserve(void * jarg1, unsigned long jarg2) {
53319   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53320   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53321
53322   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53323   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53324   {
53325     try {
53326       (arg1)->Reserve(arg2);
53327     } catch (std::out_of_range& e) {
53328       {
53329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53330       };
53331     } catch (std::exception& e) {
53332       {
53333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53334       };
53335     } catch (Dali::DaliException e) {
53336       {
53337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53338       };
53339     } catch (...) {
53340       {
53341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53342       };
53343     }
53344   }
53345
53346 }
53347
53348
53349 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
53350   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53351   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53352
53353   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53354   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53355   {
53356     try {
53357       (arg1)->Resize(arg2);
53358     } catch (std::out_of_range& e) {
53359       {
53360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53361       };
53362     } catch (std::exception& e) {
53363       {
53364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53365       };
53366     } catch (Dali::DaliException e) {
53367       {
53368         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53369       };
53370     } catch (...) {
53371       {
53372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53373       };
53374     }
53375   }
53376
53377 }
53378
53379
53380 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3) {
53381   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53382   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53383   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
53384
53385   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53386   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53387   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
53388   if (!arg3) {
53389     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
53390     return ;
53391   }
53392   {
53393     try {
53394       (arg1)->Resize(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
53395     } catch (std::out_of_range& e) {
53396       {
53397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53398       };
53399     } catch (std::exception& e) {
53400       {
53401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53402       };
53403     } catch (Dali::DaliException e) {
53404       {
53405         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53406       };
53407     } catch (...) {
53408       {
53409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53410       };
53411     }
53412   }
53413
53414 }
53415
53416
53417 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_0(void * jarg1, void * jarg2) {
53418   void * jresult ;
53419   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53420   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53421   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53422
53423   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53424   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53425   {
53426     try {
53427       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2);
53428     } catch (std::out_of_range& e) {
53429       {
53430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53431       };
53432     } catch (std::exception& e) {
53433       {
53434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53435       };
53436     } catch (Dali::DaliException e) {
53437       {
53438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53439       };
53440     } catch (...) {
53441       {
53442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53443       };
53444     }
53445   }
53446
53447   jresult = (void *)result;
53448   return jresult;
53449 }
53450
53451
53452 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
53453   void * jresult ;
53454   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53455   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53456   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53457   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53458
53459   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53460   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53461   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
53462   {
53463     try {
53464       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2,arg3);
53465     } catch (std::out_of_range& e) {
53466       {
53467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53468       };
53469     } catch (std::exception& e) {
53470       {
53471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53472       };
53473     } catch (Dali::DaliException e) {
53474       {
53475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53476       };
53477     } catch (...) {
53478       {
53479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53480       };
53481     }
53482   }
53483
53484   jresult = (void *)result;
53485   return jresult;
53486 }
53487
53488
53489 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Remove(void * jarg1, void * jarg2) {
53490   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53491   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53492
53493   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53494   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53495   {
53496     try {
53497       (arg1)->Remove(arg2);
53498     } catch (std::out_of_range& e) {
53499       {
53500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53501       };
53502     } catch (std::exception& e) {
53503       {
53504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53505       };
53506     } catch (Dali::DaliException e) {
53507       {
53508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53509       };
53510     } catch (...) {
53511       {
53512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53513       };
53514     }
53515   }
53516
53517 }
53518
53519
53520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Swap(void * jarg1, void * jarg2) {
53521   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53522   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
53523
53524   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53525   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
53526   if (!arg2) {
53527     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > & type is null", 0);
53528     return ;
53529   }
53530   {
53531     try {
53532       (arg1)->Swap(*arg2);
53533     } catch (std::out_of_range& e) {
53534       {
53535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53536       };
53537     } catch (std::exception& e) {
53538       {
53539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53540       };
53541     } catch (Dali::DaliException e) {
53542       {
53543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53544       };
53545     } catch (...) {
53546       {
53547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53548       };
53549     }
53550   }
53551
53552 }
53553
53554
53555 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Clear(void * jarg1) {
53556   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53557
53558   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53559   {
53560     try {
53561       (arg1)->Clear();
53562     } catch (std::out_of_range& e) {
53563       {
53564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53565       };
53566     } catch (std::exception& e) {
53567       {
53568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53569       };
53570     } catch (Dali::DaliException e) {
53571       {
53572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53573       };
53574     } catch (...) {
53575       {
53576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53577       };
53578     }
53579   }
53580
53581 }
53582
53583
53584 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Release(void * jarg1) {
53585   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53586
53587   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53588   {
53589     try {
53590       (arg1)->Release();
53591     } catch (std::out_of_range& e) {
53592       {
53593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53594       };
53595     } catch (std::exception& e) {
53596       {
53597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53598       };
53599     } catch (Dali::DaliException e) {
53600       {
53601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53602       };
53603     } catch (...) {
53604       {
53605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53606       };
53607     }
53608   }
53609
53610 }
53611
53612
53613 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VoidSignal() {
53614   void * jresult ;
53615   Dali::Signal< void () > *result = 0 ;
53616
53617   {
53618     try {
53619       result = (Dali::Signal< void () > *)new Dali::Signal< void () >();
53620     } catch (std::out_of_range& e) {
53621       {
53622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53623       };
53624     } catch (std::exception& e) {
53625       {
53626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53627       };
53628     } catch (Dali::DaliException e) {
53629       {
53630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53631       };
53632     } catch (...) {
53633       {
53634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53635       };
53636     }
53637   }
53638
53639   jresult = (void *)result;
53640   return jresult;
53641 }
53642
53643
53644 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VoidSignal(void * jarg1) {
53645   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53646
53647   arg1 = (Dali::Signal< void () > *)jarg1;
53648   {
53649     try {
53650       delete arg1;
53651     } catch (std::out_of_range& e) {
53652       {
53653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53654       };
53655     } catch (std::exception& e) {
53656       {
53657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53658       };
53659     } catch (Dali::DaliException e) {
53660       {
53661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53662       };
53663     } catch (...) {
53664       {
53665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53666       };
53667     }
53668   }
53669
53670 }
53671
53672
53673 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VoidSignal_Empty(void * jarg1) {
53674   unsigned int jresult ;
53675   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53676   bool result;
53677
53678   arg1 = (Dali::Signal< void () > *)jarg1;
53679   {
53680     try {
53681       result = (bool)((Dali::Signal< void () > const *)arg1)->Empty();
53682     } catch (std::out_of_range& e) {
53683       {
53684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53685       };
53686     } catch (std::exception& e) {
53687       {
53688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53689       };
53690     } catch (Dali::DaliException e) {
53691       {
53692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53693       };
53694     } catch (...) {
53695       {
53696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53697       };
53698     }
53699   }
53700
53701   jresult = result;
53702   return jresult;
53703 }
53704
53705
53706 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VoidSignal_GetConnectionCount(void * jarg1) {
53707   unsigned long jresult ;
53708   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53709   std::size_t result;
53710
53711   arg1 = (Dali::Signal< void () > *)jarg1;
53712   {
53713     try {
53714       result = ((Dali::Signal< void () > const *)arg1)->GetConnectionCount();
53715     } catch (std::out_of_range& e) {
53716       {
53717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53718       };
53719     } catch (std::exception& e) {
53720       {
53721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53722       };
53723     } catch (Dali::DaliException e) {
53724       {
53725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53726       };
53727     } catch (...) {
53728       {
53729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53730       };
53731     }
53732   }
53733
53734   jresult = (unsigned long)result;
53735   return jresult;
53736 }
53737
53738
53739 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_0(void * jarg1, void * jarg2) {
53740   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53741   void (*arg2)() = (void (*)()) 0 ;
53742
53743   arg1 = (Dali::Signal< void () > *)jarg1;
53744   arg2 = (void (*)())jarg2;
53745   {
53746     try {
53747       (arg1)->Connect(arg2);
53748     } catch (std::out_of_range& e) {
53749       {
53750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53751       };
53752     } catch (std::exception& e) {
53753       {
53754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53755       };
53756     } catch (Dali::DaliException e) {
53757       {
53758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53759       };
53760     } catch (...) {
53761       {
53762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53763       };
53764     }
53765   }
53766
53767 }
53768
53769
53770 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Disconnect(void * jarg1, void * jarg2) {
53771   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53772   void (*arg2)() = (void (*)()) 0 ;
53773
53774   arg1 = (Dali::Signal< void () > *)jarg1;
53775   arg2 = (void (*)())jarg2;
53776   {
53777     try {
53778       (arg1)->Disconnect(arg2);
53779     } catch (std::out_of_range& e) {
53780       {
53781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53782       };
53783     } catch (std::exception& e) {
53784       {
53785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53786       };
53787     } catch (Dali::DaliException e) {
53788       {
53789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53790       };
53791     } catch (...) {
53792       {
53793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53794       };
53795     }
53796   }
53797
53798 }
53799
53800
53801 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
53802   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53803   Dali::ConnectionTrackerInterface *arg2 = (Dali::ConnectionTrackerInterface *) 0 ;
53804   Dali::FunctorDelegate *arg3 = (Dali::FunctorDelegate *) 0 ;
53805
53806   arg1 = (Dali::Signal< void () > *)jarg1;
53807   arg2 = (Dali::ConnectionTrackerInterface *)jarg2;
53808   arg3 = (Dali::FunctorDelegate *)jarg3;
53809   {
53810     try {
53811       (arg1)->Connect(arg2,arg3);
53812     } catch (std::out_of_range& e) {
53813       {
53814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53815       };
53816     } catch (std::exception& e) {
53817       {
53818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53819       };
53820     } catch (Dali::DaliException e) {
53821       {
53822         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53823       };
53824     } catch (...) {
53825       {
53826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53827       };
53828     }
53829   }
53830
53831 }
53832
53833
53834 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Emit(void * jarg1) {
53835   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53836
53837   arg1 = (Dali::Signal< void () > *)jarg1;
53838   {
53839     try {
53840       (arg1)->Emit();
53841     } catch (std::out_of_range& e) {
53842       {
53843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53844       };
53845     } catch (std::exception& e) {
53846       {
53847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53848       };
53849     } catch (Dali::DaliException e) {
53850       {
53851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53852       };
53853     } catch (...) {
53854       {
53855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53856       };
53857     }
53858   }
53859
53860 }
53861
53862
53863 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FloatSignal_Empty(void * jarg1) {
53864   unsigned int jresult ;
53865   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
53866   bool result;
53867
53868   arg1 = (Dali::Signal< void (float) > *)jarg1;
53869   {
53870     try {
53871       result = (bool)Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty((Dali::Signal< void (float) > const *)arg1);
53872     } catch (std::out_of_range& e) {
53873       {
53874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53875       };
53876     } catch (std::exception& e) {
53877       {
53878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53879       };
53880     } catch (Dali::DaliException e) {
53881       {
53882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53883       };
53884     } catch (...) {
53885       {
53886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53887       };
53888     }
53889   }
53890
53891   jresult = result;
53892   return jresult;
53893 }
53894
53895
53896 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FloatSignal_GetConnectionCount(void * jarg1) {
53897   unsigned long jresult ;
53898   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
53899   std::size_t result;
53900
53901   arg1 = (Dali::Signal< void (float) > *)jarg1;
53902   {
53903     try {
53904       result = Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount((Dali::Signal< void (float) > const *)arg1);
53905     } catch (std::out_of_range& e) {
53906       {
53907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53908       };
53909     } catch (std::exception& e) {
53910       {
53911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53912       };
53913     } catch (Dali::DaliException e) {
53914       {
53915         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53916       };
53917     } catch (...) {
53918       {
53919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53920       };
53921     }
53922   }
53923
53924   jresult = (unsigned long)result;
53925   return jresult;
53926 }
53927
53928
53929 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Connect(void * jarg1, void * jarg2) {
53930   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
53931   void (*arg2)(float) = (void (*)(float)) 0 ;
53932
53933   arg1 = (Dali::Signal< void (float) > *)jarg1;
53934   arg2 = (void (*)(float))jarg2;
53935   {
53936     try {
53937       Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(arg1,arg2);
53938     } catch (std::out_of_range& e) {
53939       {
53940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53941       };
53942     } catch (std::exception& e) {
53943       {
53944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53945       };
53946     } catch (Dali::DaliException e) {
53947       {
53948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53949       };
53950     } catch (...) {
53951       {
53952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53953       };
53954     }
53955   }
53956
53957 }
53958
53959
53960 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Disconnect(void * jarg1, void * jarg2) {
53961   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
53962   void (*arg2)(float) = (void (*)(float)) 0 ;
53963
53964   arg1 = (Dali::Signal< void (float) > *)jarg1;
53965   arg2 = (void (*)(float))jarg2;
53966   {
53967     try {
53968       Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(arg1,arg2);
53969     } catch (std::out_of_range& e) {
53970       {
53971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53972       };
53973     } catch (std::exception& e) {
53974       {
53975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53976       };
53977     } catch (Dali::DaliException e) {
53978       {
53979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53980       };
53981     } catch (...) {
53982       {
53983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53984       };
53985     }
53986   }
53987
53988 }
53989
53990
53991 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Emit(void * jarg1, float jarg2) {
53992   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
53993   float arg2 ;
53994
53995   arg1 = (Dali::Signal< void (float) > *)jarg1;
53996   arg2 = (float)jarg2;
53997   {
53998     try {
53999       Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(arg1,arg2);
54000     } catch (std::out_of_range& e) {
54001       {
54002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54003       };
54004     } catch (std::exception& e) {
54005       {
54006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54007       };
54008     } catch (Dali::DaliException e) {
54009       {
54010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54011       };
54012     } catch (...) {
54013       {
54014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54015       };
54016     }
54017   }
54018
54019 }
54020
54021
54022 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FloatSignal() {
54023   void * jresult ;
54024   Dali::Signal< void (float) > *result = 0 ;
54025
54026   {
54027     try {
54028       result = (Dali::Signal< void (float) > *)new Dali::Signal< void (float) >();
54029     } catch (std::out_of_range& e) {
54030       {
54031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54032       };
54033     } catch (std::exception& e) {
54034       {
54035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54036       };
54037     } catch (Dali::DaliException e) {
54038       {
54039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54040       };
54041     } catch (...) {
54042       {
54043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54044       };
54045     }
54046   }
54047
54048   jresult = (void *)result;
54049   return jresult;
54050 }
54051
54052
54053 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FloatSignal(void * jarg1) {
54054   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
54055
54056   arg1 = (Dali::Signal< void (float) > *)jarg1;
54057   {
54058     try {
54059       delete arg1;
54060     } catch (std::out_of_range& e) {
54061       {
54062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54063       };
54064     } catch (std::exception& e) {
54065       {
54066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54067       };
54068     } catch (Dali::DaliException e) {
54069       {
54070         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54071       };
54072     } catch (...) {
54073       {
54074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54075       };
54076     }
54077   }
54078
54079 }
54080
54081
54082 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Empty(void * jarg1) {
54083   unsigned int jresult ;
54084   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54085   bool result;
54086
54087   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54088   {
54089     try {
54090       result = (bool)Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
54091     } catch (std::out_of_range& e) {
54092       {
54093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54094       };
54095     } catch (std::exception& e) {
54096       {
54097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54098       };
54099     } catch (Dali::DaliException e) {
54100       {
54101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54102       };
54103     } catch (...) {
54104       {
54105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54106       };
54107     }
54108   }
54109
54110   jresult = result;
54111   return jresult;
54112 }
54113
54114
54115 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_GetConnectionCount(void * jarg1) {
54116   unsigned long jresult ;
54117   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54118   std::size_t result;
54119
54120   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54121   {
54122     try {
54123       result = Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
54124     } catch (std::out_of_range& e) {
54125       {
54126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54127       };
54128     } catch (std::exception& e) {
54129       {
54130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54131       };
54132     } catch (Dali::DaliException e) {
54133       {
54134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54135       };
54136     } catch (...) {
54137       {
54138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54139       };
54140     }
54141   }
54142
54143   jresult = (unsigned long)result;
54144   return jresult;
54145 }
54146
54147
54148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Connect(void * jarg1, void * jarg2) {
54149   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54150   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
54151
54152   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54153   arg2 = (void (*)(Dali::BaseHandle))jarg2;
54154   {
54155     try {
54156       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(arg1,arg2);
54157     } catch (std::out_of_range& e) {
54158       {
54159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54160       };
54161     } catch (std::exception& e) {
54162       {
54163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54164       };
54165     } catch (Dali::DaliException e) {
54166       {
54167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54168       };
54169     } catch (...) {
54170       {
54171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54172       };
54173     }
54174   }
54175
54176 }
54177
54178
54179 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Disconnect(void * jarg1, void * jarg2) {
54180   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54181   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
54182
54183   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54184   arg2 = (void (*)(Dali::BaseHandle))jarg2;
54185   {
54186     try {
54187       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(arg1,arg2);
54188     } catch (std::out_of_range& e) {
54189       {
54190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54191       };
54192     } catch (std::exception& e) {
54193       {
54194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54195       };
54196     } catch (Dali::DaliException e) {
54197       {
54198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54199       };
54200     } catch (...) {
54201       {
54202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54203       };
54204     }
54205   }
54206
54207 }
54208
54209
54210 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Emit(void * jarg1, void * jarg2) {
54211   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54212   Dali::BaseHandle arg2 ;
54213   Dali::BaseHandle *argp2 ;
54214
54215   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54216   argp2 = (Dali::BaseHandle *)jarg2;
54217   if (!argp2) {
54218     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
54219     return ;
54220   }
54221   arg2 = *argp2;
54222   {
54223     try {
54224       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(arg1,arg2);
54225     } catch (std::out_of_range& e) {
54226       {
54227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54228       };
54229     } catch (std::exception& e) {
54230       {
54231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54232       };
54233     } catch (Dali::DaliException e) {
54234       {
54235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54236       };
54237     } catch (...) {
54238       {
54239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54240       };
54241     }
54242   }
54243
54244 }
54245
54246
54247 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectCreatedSignal() {
54248   void * jresult ;
54249   Dali::Signal< void (Dali::BaseHandle) > *result = 0 ;
54250
54251   {
54252     try {
54253       result = (Dali::Signal< void (Dali::BaseHandle) > *)new Dali::Signal< void (Dali::BaseHandle) >();
54254     } catch (std::out_of_range& e) {
54255       {
54256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54257       };
54258     } catch (std::exception& e) {
54259       {
54260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54261       };
54262     } catch (Dali::DaliException e) {
54263       {
54264         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54265       };
54266     } catch (...) {
54267       {
54268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54269       };
54270     }
54271   }
54272
54273   jresult = (void *)result;
54274   return jresult;
54275 }
54276
54277
54278 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectCreatedSignal(void * jarg1) {
54279   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54280
54281   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54282   {
54283     try {
54284       delete arg1;
54285     } catch (std::out_of_range& e) {
54286       {
54287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54288       };
54289     } catch (std::exception& e) {
54290       {
54291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54292       };
54293     } catch (Dali::DaliException e) {
54294       {
54295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54296       };
54297     } catch (...) {
54298       {
54299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54300       };
54301     }
54302   }
54303
54304 }
54305
54306
54307 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Empty(void * jarg1) {
54308   unsigned int jresult ;
54309   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54310   bool result;
54311
54312   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54313   {
54314     try {
54315       result = (bool)Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
54316     } catch (std::out_of_range& e) {
54317       {
54318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54319       };
54320     } catch (std::exception& e) {
54321       {
54322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54323       };
54324     } catch (Dali::DaliException e) {
54325       {
54326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54327       };
54328     } catch (...) {
54329       {
54330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54331       };
54332     }
54333   }
54334
54335   jresult = result;
54336   return jresult;
54337 }
54338
54339
54340 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_GetConnectionCount(void * jarg1) {
54341   unsigned long jresult ;
54342   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54343   std::size_t result;
54344
54345   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54346   {
54347     try {
54348       result = Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
54349     } catch (std::out_of_range& e) {
54350       {
54351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54352       };
54353     } catch (std::exception& e) {
54354       {
54355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54356       };
54357     } catch (Dali::DaliException e) {
54358       {
54359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54360       };
54361     } catch (...) {
54362       {
54363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54364       };
54365     }
54366   }
54367
54368   jresult = (unsigned long)result;
54369   return jresult;
54370 }
54371
54372
54373 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Connect(void * jarg1, void * jarg2) {
54374   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54375   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
54376
54377   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54378   arg2 = (void (*)(Dali::RefObject const *))jarg2;
54379   {
54380     try {
54381       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(arg1,arg2);
54382     } catch (std::out_of_range& e) {
54383       {
54384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54385       };
54386     } catch (std::exception& e) {
54387       {
54388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54389       };
54390     } catch (Dali::DaliException e) {
54391       {
54392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54393       };
54394     } catch (...) {
54395       {
54396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54397       };
54398     }
54399   }
54400
54401 }
54402
54403
54404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Disconnect(void * jarg1, void * jarg2) {
54405   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54406   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
54407
54408   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54409   arg2 = (void (*)(Dali::RefObject const *))jarg2;
54410   {
54411     try {
54412       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(arg1,arg2);
54413     } catch (std::out_of_range& e) {
54414       {
54415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54416       };
54417     } catch (std::exception& e) {
54418       {
54419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54420       };
54421     } catch (Dali::DaliException e) {
54422       {
54423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54424       };
54425     } catch (...) {
54426       {
54427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54428       };
54429     }
54430   }
54431
54432 }
54433
54434
54435 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Emit(void * jarg1, void * jarg2) {
54436   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54437   Dali::RefObject *arg2 = (Dali::RefObject *) 0 ;
54438
54439   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54440   arg2 = (Dali::RefObject *)jarg2;
54441   {
54442     try {
54443       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(arg1,(Dali::RefObject const *)arg2);
54444     } catch (std::out_of_range& e) {
54445       {
54446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54447       };
54448     } catch (std::exception& e) {
54449       {
54450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54451       };
54452     } catch (Dali::DaliException e) {
54453       {
54454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54455       };
54456     } catch (...) {
54457       {
54458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54459       };
54460     }
54461   }
54462
54463 }
54464
54465
54466 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectDestroyedSignal() {
54467   void * jresult ;
54468   Dali::Signal< void (Dali::RefObject const *) > *result = 0 ;
54469
54470   {
54471     try {
54472       result = (Dali::Signal< void (Dali::RefObject const *) > *)new Dali::Signal< void (Dali::RefObject const *) >();
54473     } catch (std::out_of_range& e) {
54474       {
54475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54476       };
54477     } catch (std::exception& e) {
54478       {
54479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54480       };
54481     } catch (Dali::DaliException e) {
54482       {
54483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54484       };
54485     } catch (...) {
54486       {
54487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54488       };
54489     }
54490   }
54491
54492   jresult = (void *)result;
54493   return jresult;
54494 }
54495
54496
54497 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectDestroyedSignal(void * jarg1) {
54498   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54499
54500   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54501   {
54502     try {
54503       delete arg1;
54504     } catch (std::out_of_range& e) {
54505       {
54506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54507       };
54508     } catch (std::exception& e) {
54509       {
54510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54511       };
54512     } catch (Dali::DaliException e) {
54513       {
54514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54515       };
54516     } catch (...) {
54517       {
54518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54519       };
54520     }
54521   }
54522
54523 }
54524
54525
54526 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Empty(void * jarg1) {
54527   unsigned int jresult ;
54528   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54529   bool result;
54530
54531   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54532   {
54533     try {
54534       result = (bool)Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
54535     } catch (std::out_of_range& e) {
54536       {
54537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54538       };
54539     } catch (std::exception& e) {
54540       {
54541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54542       };
54543     } catch (Dali::DaliException e) {
54544       {
54545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54546       };
54547     } catch (...) {
54548       {
54549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54550       };
54551     }
54552   }
54553
54554   jresult = result;
54555   return jresult;
54556 }
54557
54558
54559 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_GetConnectionCount(void * jarg1) {
54560   unsigned long jresult ;
54561   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54562   std::size_t result;
54563
54564   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54565   {
54566     try {
54567       result = Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
54568     } catch (std::out_of_range& e) {
54569       {
54570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54571       };
54572     } catch (std::exception& e) {
54573       {
54574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54575       };
54576     } catch (Dali::DaliException e) {
54577       {
54578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54579       };
54580     } catch (...) {
54581       {
54582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54583       };
54584     }
54585   }
54586
54587   jresult = (unsigned long)result;
54588   return jresult;
54589 }
54590
54591
54592 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Connect(void * jarg1, void * jarg2) {
54593   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54594   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
54595
54596   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54597   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
54598   {
54599     try {
54600       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(arg1,arg2);
54601     } catch (std::out_of_range& e) {
54602       {
54603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54604       };
54605     } catch (std::exception& e) {
54606       {
54607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54608       };
54609     } catch (Dali::DaliException e) {
54610       {
54611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54612       };
54613     } catch (...) {
54614       {
54615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54616       };
54617     }
54618   }
54619
54620 }
54621
54622
54623 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Disconnect(void * jarg1, void * jarg2) {
54624   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54625   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
54626
54627   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54628   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
54629   {
54630     try {
54631       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(arg1,arg2);
54632     } catch (std::out_of_range& e) {
54633       {
54634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54635       };
54636     } catch (std::exception& e) {
54637       {
54638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54639       };
54640     } catch (Dali::DaliException e) {
54641       {
54642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54643       };
54644     } catch (...) {
54645       {
54646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54647       };
54648     }
54649   }
54650
54651 }
54652
54653
54654 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Emit(void * jarg1, void * jarg2) {
54655   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54656   Dali::PropertyNotification *arg2 = 0 ;
54657
54658   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54659   arg2 = (Dali::PropertyNotification *)jarg2;
54660   if (!arg2) {
54661     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification & type is null", 0);
54662     return ;
54663   }
54664   {
54665     try {
54666       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(arg1,*arg2);
54667     } catch (std::out_of_range& e) {
54668       {
54669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54670       };
54671     } catch (std::exception& e) {
54672       {
54673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54674       };
54675     } catch (Dali::DaliException e) {
54676       {
54677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54678       };
54679     } catch (...) {
54680       {
54681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54682       };
54683     }
54684   }
54685
54686 }
54687
54688
54689 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotifySignal() {
54690   void * jresult ;
54691   Dali::Signal< void (Dali::PropertyNotification &) > *result = 0 ;
54692
54693   {
54694     try {
54695       result = (Dali::Signal< void (Dali::PropertyNotification &) > *)new Dali::Signal< void (Dali::PropertyNotification &) >();
54696     } catch (std::out_of_range& e) {
54697       {
54698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54699       };
54700     } catch (std::exception& e) {
54701       {
54702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54703       };
54704     } catch (Dali::DaliException e) {
54705       {
54706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54707       };
54708     } catch (...) {
54709       {
54710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54711       };
54712     }
54713   }
54714
54715   jresult = (void *)result;
54716   return jresult;
54717 }
54718
54719
54720 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotifySignal(void * jarg1) {
54721   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54722
54723   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54724   {
54725     try {
54726       delete arg1;
54727     } catch (std::out_of_range& e) {
54728       {
54729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54730       };
54731     } catch (std::exception& e) {
54732       {
54733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54734       };
54735     } catch (Dali::DaliException e) {
54736       {
54737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54738       };
54739     } catch (...) {
54740       {
54741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54742       };
54743     }
54744   }
54745
54746 }
54747
54748
54749 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ImageSignal_Empty(void * jarg1) {
54750   unsigned int jresult ;
54751   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54752   bool result;
54753
54754   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54755   {
54756     try {
54757       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty((Dali::Signal< void (Dali::Image) > const *)arg1);
54758     } catch (std::out_of_range& e) {
54759       {
54760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54761       };
54762     } catch (std::exception& e) {
54763       {
54764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54765       };
54766     } catch (Dali::DaliException e) {
54767       {
54768         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54769       };
54770     } catch (...) {
54771       {
54772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54773       };
54774     }
54775   }
54776
54777   jresult = result;
54778   return jresult;
54779 }
54780
54781
54782 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ImageSignal_GetConnectionCount(void * jarg1) {
54783   unsigned long jresult ;
54784   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54785   std::size_t result;
54786
54787   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54788   {
54789     try {
54790       result = Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Image) > const *)arg1);
54791     } catch (std::out_of_range& e) {
54792       {
54793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54794       };
54795     } catch (std::exception& e) {
54796       {
54797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54798       };
54799     } catch (Dali::DaliException e) {
54800       {
54801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54802       };
54803     } catch (...) {
54804       {
54805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54806       };
54807     }
54808   }
54809
54810   jresult = (unsigned long)result;
54811   return jresult;
54812 }
54813
54814
54815 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Connect(void * jarg1, void * jarg2) {
54816   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54817   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
54818
54819   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54820   arg2 = (void (*)(Dali::Image))jarg2;
54821   {
54822     try {
54823       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(arg1,arg2);
54824     } catch (std::out_of_range& e) {
54825       {
54826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54827       };
54828     } catch (std::exception& e) {
54829       {
54830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54831       };
54832     } catch (Dali::DaliException e) {
54833       {
54834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54835       };
54836     } catch (...) {
54837       {
54838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54839       };
54840     }
54841   }
54842
54843 }
54844
54845
54846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Disconnect(void * jarg1, void * jarg2) {
54847   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54848   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
54849
54850   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54851   arg2 = (void (*)(Dali::Image))jarg2;
54852   {
54853     try {
54854       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(arg1,arg2);
54855     } catch (std::out_of_range& e) {
54856       {
54857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54858       };
54859     } catch (std::exception& e) {
54860       {
54861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54862       };
54863     } catch (Dali::DaliException e) {
54864       {
54865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54866       };
54867     } catch (...) {
54868       {
54869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54870       };
54871     }
54872   }
54873
54874 }
54875
54876
54877 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Emit(void * jarg1, void * jarg2) {
54878   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54879   Dali::Image arg2 ;
54880   Dali::Image *argp2 ;
54881
54882   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54883   argp2 = (Dali::Image *)jarg2;
54884   if (!argp2) {
54885     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
54886     return ;
54887   }
54888   arg2 = *argp2;
54889   {
54890     try {
54891       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(arg1,arg2);
54892     } catch (std::out_of_range& e) {
54893       {
54894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54895       };
54896     } catch (std::exception& e) {
54897       {
54898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54899       };
54900     } catch (Dali::DaliException e) {
54901       {
54902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54903       };
54904     } catch (...) {
54905       {
54906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54907       };
54908     }
54909   }
54910
54911 }
54912
54913
54914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageSignal() {
54915   void * jresult ;
54916   Dali::Signal< void (Dali::Image) > *result = 0 ;
54917
54918   {
54919     try {
54920       result = (Dali::Signal< void (Dali::Image) > *)new Dali::Signal< void (Dali::Image) >();
54921     } catch (std::out_of_range& e) {
54922       {
54923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54924       };
54925     } catch (std::exception& e) {
54926       {
54927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54928       };
54929     } catch (Dali::DaliException e) {
54930       {
54931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54932       };
54933     } catch (...) {
54934       {
54935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54936       };
54937     }
54938   }
54939
54940   jresult = (void *)result;
54941   return jresult;
54942 }
54943
54944
54945 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageSignal(void * jarg1) {
54946   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54947
54948   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54949   {
54950     try {
54951       delete arg1;
54952     } catch (std::out_of_range& e) {
54953       {
54954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54955       };
54956     } catch (std::exception& e) {
54957       {
54958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54959       };
54960     } catch (Dali::DaliException e) {
54961       {
54962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54963       };
54964     } catch (...) {
54965       {
54966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54967       };
54968     }
54969   }
54970
54971 }
54972
54973
54974 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskSignal() {
54975   void * jresult ;
54976   Dali::Signal< void (Dali::RenderTask &) > *result = 0 ;
54977
54978   {
54979     try {
54980       result = (Dali::Signal< void (Dali::RenderTask &) > *)new Dali::Signal< void (Dali::RenderTask &) >();
54981     } catch (std::out_of_range& e) {
54982       {
54983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54984       };
54985     } catch (std::exception& e) {
54986       {
54987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54988       };
54989     } catch (Dali::DaliException e) {
54990       {
54991         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54992       };
54993     } catch (...) {
54994       {
54995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54996       };
54997     }
54998   }
54999
55000   jresult = (void *)result;
55001   return jresult;
55002 }
55003
55004
55005 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskSignal(void * jarg1) {
55006   Dali::Signal< void (Dali::RenderTask &) > *arg1 = (Dali::Signal< void (Dali::RenderTask &) > *) 0 ;
55007
55008   arg1 = (Dali::Signal< void (Dali::RenderTask &) > *)jarg1;
55009   {
55010     try {
55011       delete arg1;
55012     } catch (std::out_of_range& e) {
55013       {
55014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55015       };
55016     } catch (std::exception& e) {
55017       {
55018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55019       };
55020     } catch (Dali::DaliException e) {
55021       {
55022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55023       };
55024     } catch (...) {
55025       {
55026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55027       };
55028     }
55029   }
55030
55031 }
55032
55033
55034 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Empty(void * jarg1) {
55035   unsigned int jresult ;
55036   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55037   bool result;
55038
55039   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55040   {
55041     try {
55042       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);
55043     } catch (std::out_of_range& e) {
55044       {
55045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55046       };
55047     } catch (std::exception& e) {
55048       {
55049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55050       };
55051     } catch (Dali::DaliException e) {
55052       {
55053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55054       };
55055     } catch (...) {
55056       {
55057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55058       };
55059     }
55060   }
55061
55062   jresult = result;
55063   return jresult;
55064 }
55065
55066
55067 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_GetConnectionCount(void * jarg1) {
55068   unsigned long jresult ;
55069   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55070   std::size_t result;
55071
55072   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55073   {
55074     try {
55075       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);
55076     } catch (std::out_of_range& e) {
55077       {
55078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55079       };
55080     } catch (std::exception& e) {
55081       {
55082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55083       };
55084     } catch (Dali::DaliException e) {
55085       {
55086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55087       };
55088     } catch (...) {
55089       {
55090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55091       };
55092     }
55093   }
55094
55095   jresult = (unsigned long)result;
55096   return jresult;
55097 }
55098
55099
55100 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
55101   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55102   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
55103
55104   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55105   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
55106   {
55107     try {
55108       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55109     } catch (std::out_of_range& e) {
55110       {
55111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55112       };
55113     } catch (std::exception& e) {
55114       {
55115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55116       };
55117     } catch (Dali::DaliException e) {
55118       {
55119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55120       };
55121     } catch (...) {
55122       {
55123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55124       };
55125     }
55126   }
55127
55128 }
55129
55130
55131 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
55132   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55133   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
55134
55135   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55136   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
55137   {
55138     try {
55139       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55140     } catch (std::out_of_range& e) {
55141       {
55142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55143       };
55144     } catch (std::exception& e) {
55145       {
55146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55147       };
55148     } catch (Dali::DaliException e) {
55149       {
55150         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55151       };
55152     } catch (...) {
55153       {
55154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55155       };
55156     }
55157   }
55158
55159 }
55160
55161
55162 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55163   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55164   Dali::Actor arg2 ;
55165   Dali::LongPressGesture *arg3 = 0 ;
55166   Dali::Actor *argp2 ;
55167
55168   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55169   argp2 = (Dali::Actor *)jarg2;
55170   if (!argp2) {
55171     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55172     return ;
55173   }
55174   arg2 = *argp2;
55175   arg3 = (Dali::LongPressGesture *)jarg3;
55176   if (!arg3) {
55177     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
55178     return ;
55179   }
55180   {
55181     try {
55182       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::LongPressGesture const &)*arg3);
55183     } catch (std::out_of_range& e) {
55184       {
55185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55186       };
55187     } catch (std::exception& e) {
55188       {
55189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55190       };
55191     } catch (Dali::DaliException e) {
55192       {
55193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55194       };
55195     } catch (...) {
55196       {
55197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55198       };
55199     }
55200   }
55201
55202 }
55203
55204
55205 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetectedSignal() {
55206   void * jresult ;
55207   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *result = 0 ;
55208
55209   {
55210     try {
55211       result = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) >();
55212     } catch (std::out_of_range& e) {
55213       {
55214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55215       };
55216     } catch (std::exception& e) {
55217       {
55218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55219       };
55220     } catch (Dali::DaliException e) {
55221       {
55222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55223       };
55224     } catch (...) {
55225       {
55226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55227       };
55228     }
55229   }
55230
55231   jresult = (void *)result;
55232   return jresult;
55233 }
55234
55235
55236 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetectedSignal(void * jarg1) {
55237   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55238
55239   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55240   {
55241     try {
55242       delete arg1;
55243     } catch (std::out_of_range& e) {
55244       {
55245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55246       };
55247     } catch (std::exception& e) {
55248       {
55249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55250       };
55251     } catch (Dali::DaliException e) {
55252       {
55253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55254       };
55255     } catch (...) {
55256       {
55257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55258       };
55259     }
55260   }
55261
55262 }
55263
55264
55265 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Empty(void * jarg1) {
55266   unsigned int jresult ;
55267   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55268   bool result;
55269
55270   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55271   {
55272     try {
55273       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);
55274     } catch (std::out_of_range& e) {
55275       {
55276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55277       };
55278     } catch (std::exception& e) {
55279       {
55280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55281       };
55282     } catch (Dali::DaliException e) {
55283       {
55284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55285       };
55286     } catch (...) {
55287       {
55288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55289       };
55290     }
55291   }
55292
55293   jresult = result;
55294   return jresult;
55295 }
55296
55297
55298 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_GetConnectionCount(void * jarg1) {
55299   unsigned long jresult ;
55300   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55301   std::size_t result;
55302
55303   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55304   {
55305     try {
55306       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);
55307     } catch (std::out_of_range& e) {
55308       {
55309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55310       };
55311     } catch (std::exception& e) {
55312       {
55313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55314       };
55315     } catch (Dali::DaliException e) {
55316       {
55317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55318       };
55319     } catch (...) {
55320       {
55321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55322       };
55323     }
55324   }
55325
55326   jresult = (unsigned long)result;
55327   return jresult;
55328 }
55329
55330
55331 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Connect(void * jarg1, void * jarg2) {
55332   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55333   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
55334
55335   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55336   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
55337   {
55338     try {
55339       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55340     } catch (std::out_of_range& e) {
55341       {
55342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55343       };
55344     } catch (std::exception& e) {
55345       {
55346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55347       };
55348     } catch (Dali::DaliException e) {
55349       {
55350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55351       };
55352     } catch (...) {
55353       {
55354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55355       };
55356     }
55357   }
55358
55359 }
55360
55361
55362 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Disconnect(void * jarg1, void * jarg2) {
55363   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55364   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
55365
55366   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55367   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
55368   {
55369     try {
55370       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55371     } catch (std::out_of_range& e) {
55372       {
55373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55374       };
55375     } catch (std::exception& e) {
55376       {
55377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55378       };
55379     } catch (Dali::DaliException e) {
55380       {
55381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55382       };
55383     } catch (...) {
55384       {
55385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55386       };
55387     }
55388   }
55389
55390 }
55391
55392
55393 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55394   unsigned int jresult ;
55395   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55396   Dali::Actor arg2 ;
55397   Dali::TouchData *arg3 = 0 ;
55398   Dali::Actor *argp2 ;
55399   bool result;
55400
55401   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55402   argp2 = (Dali::Actor *)jarg2;
55403   if (!argp2) {
55404     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55405     return 0;
55406   }
55407   arg2 = *argp2;
55408   arg3 = (Dali::TouchData *)jarg3;
55409   if (!arg3) {
55410     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
55411     return 0;
55412   }
55413   {
55414     try {
55415       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TouchData const &)*arg3);
55416     } catch (std::out_of_range& e) {
55417       {
55418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55419       };
55420     } catch (std::exception& e) {
55421       {
55422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55423       };
55424     } catch (Dali::DaliException e) {
55425       {
55426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55427       };
55428     } catch (...) {
55429       {
55430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55431       };
55432     }
55433   }
55434
55435   jresult = result;
55436   return jresult;
55437 }
55438
55439
55440 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorTouchDataSignal() {
55441   void * jresult ;
55442   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *result = 0 ;
55443
55444   {
55445     try {
55446       result = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) >();
55447     } catch (std::out_of_range& e) {
55448       {
55449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55450       };
55451     } catch (std::exception& e) {
55452       {
55453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55454       };
55455     } catch (Dali::DaliException e) {
55456       {
55457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55458       };
55459     } catch (...) {
55460       {
55461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55462       };
55463     }
55464   }
55465
55466   jresult = (void *)result;
55467   return jresult;
55468 }
55469
55470
55471 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorTouchDataSignal(void * jarg1) {
55472   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55473
55474   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55475   {
55476     try {
55477       delete arg1;
55478     } catch (std::out_of_range& e) {
55479       {
55480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55481       };
55482     } catch (std::exception& e) {
55483       {
55484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55485       };
55486     } catch (Dali::DaliException e) {
55487       {
55488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55489       };
55490     } catch (...) {
55491       {
55492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55493       };
55494     }
55495   }
55496
55497 }
55498
55499
55500 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Empty(void * jarg1) {
55501   unsigned int jresult ;
55502   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55503   bool result;
55504
55505   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55506   {
55507     try {
55508       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);
55509     } catch (std::out_of_range& e) {
55510       {
55511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55512       };
55513     } catch (std::exception& e) {
55514       {
55515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55516       };
55517     } catch (Dali::DaliException e) {
55518       {
55519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55520       };
55521     } catch (...) {
55522       {
55523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55524       };
55525     }
55526   }
55527
55528   jresult = result;
55529   return jresult;
55530 }
55531
55532
55533 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorHoverSignal_GetConnectionCount(void * jarg1) {
55534   unsigned long jresult ;
55535   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55536   std::size_t result;
55537
55538   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55539   {
55540     try {
55541       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);
55542     } catch (std::out_of_range& e) {
55543       {
55544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55545       };
55546     } catch (std::exception& e) {
55547       {
55548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55549       };
55550     } catch (Dali::DaliException e) {
55551       {
55552         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55553       };
55554     } catch (...) {
55555       {
55556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55557       };
55558     }
55559   }
55560
55561   jresult = (unsigned long)result;
55562   return jresult;
55563 }
55564
55565
55566 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Connect(void * jarg1, void * jarg2) {
55567   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55568   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
55569
55570   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55571   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
55572   {
55573     try {
55574       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55575     } catch (std::out_of_range& e) {
55576       {
55577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55578       };
55579     } catch (std::exception& e) {
55580       {
55581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55582       };
55583     } catch (Dali::DaliException e) {
55584       {
55585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55586       };
55587     } catch (...) {
55588       {
55589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55590       };
55591     }
55592   }
55593
55594 }
55595
55596
55597 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Disconnect(void * jarg1, void * jarg2) {
55598   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55599   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
55600
55601   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55602   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
55603   {
55604     try {
55605       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55606     } catch (std::out_of_range& e) {
55607       {
55608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55609       };
55610     } catch (std::exception& e) {
55611       {
55612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55613       };
55614     } catch (Dali::DaliException e) {
55615       {
55616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55617       };
55618     } catch (...) {
55619       {
55620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55621       };
55622     }
55623   }
55624
55625 }
55626
55627
55628 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55629   unsigned int jresult ;
55630   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55631   Dali::Actor arg2 ;
55632   Dali::HoverEvent *arg3 = 0 ;
55633   Dali::Actor *argp2 ;
55634   bool result;
55635
55636   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55637   argp2 = (Dali::Actor *)jarg2;
55638   if (!argp2) {
55639     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55640     return 0;
55641   }
55642   arg2 = *argp2;
55643   arg3 = (Dali::HoverEvent *)jarg3;
55644   if (!arg3) {
55645     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
55646     return 0;
55647   }
55648   {
55649     try {
55650       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::HoverEvent const &)*arg3);
55651     } catch (std::out_of_range& e) {
55652       {
55653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55654       };
55655     } catch (std::exception& e) {
55656       {
55657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55658       };
55659     } catch (Dali::DaliException e) {
55660       {
55661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55662       };
55663     } catch (...) {
55664       {
55665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55666       };
55667     }
55668   }
55669
55670   jresult = result;
55671   return jresult;
55672 }
55673
55674
55675 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorHoverSignal() {
55676   void * jresult ;
55677   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *result = 0 ;
55678
55679   {
55680     try {
55681       result = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) >();
55682     } catch (std::out_of_range& e) {
55683       {
55684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55685       };
55686     } catch (std::exception& e) {
55687       {
55688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55689       };
55690     } catch (Dali::DaliException e) {
55691       {
55692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55693       };
55694     } catch (...) {
55695       {
55696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55697       };
55698     }
55699   }
55700
55701   jresult = (void *)result;
55702   return jresult;
55703 }
55704
55705
55706 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorHoverSignal(void * jarg1) {
55707   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55708
55709   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55710   {
55711     try {
55712       delete arg1;
55713     } catch (std::out_of_range& e) {
55714       {
55715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55716       };
55717     } catch (std::exception& e) {
55718       {
55719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55720       };
55721     } catch (Dali::DaliException e) {
55722       {
55723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55724       };
55725     } catch (...) {
55726       {
55727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55728       };
55729     }
55730   }
55731
55732 }
55733
55734
55735 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Empty(void * jarg1) {
55736   unsigned int jresult ;
55737   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55738   bool result;
55739
55740   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55741   {
55742     try {
55743       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);
55744     } catch (std::out_of_range& e) {
55745       {
55746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55747       };
55748     } catch (std::exception& e) {
55749       {
55750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55751       };
55752     } catch (Dali::DaliException e) {
55753       {
55754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55755       };
55756     } catch (...) {
55757       {
55758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55759       };
55760     }
55761   }
55762
55763   jresult = result;
55764   return jresult;
55765 }
55766
55767
55768 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorWheelSignal_GetConnectionCount(void * jarg1) {
55769   unsigned long jresult ;
55770   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55771   std::size_t result;
55772
55773   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55774   {
55775     try {
55776       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);
55777     } catch (std::out_of_range& e) {
55778       {
55779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55780       };
55781     } catch (std::exception& e) {
55782       {
55783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55784       };
55785     } catch (Dali::DaliException e) {
55786       {
55787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55788       };
55789     } catch (...) {
55790       {
55791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55792       };
55793     }
55794   }
55795
55796   jresult = (unsigned long)result;
55797   return jresult;
55798 }
55799
55800
55801 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Connect(void * jarg1, void * jarg2) {
55802   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55803   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
55804
55805   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55806   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
55807   {
55808     try {
55809       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55810     } catch (std::out_of_range& e) {
55811       {
55812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55813       };
55814     } catch (std::exception& e) {
55815       {
55816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55817       };
55818     } catch (Dali::DaliException e) {
55819       {
55820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55821       };
55822     } catch (...) {
55823       {
55824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55825       };
55826     }
55827   }
55828
55829 }
55830
55831
55832 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Disconnect(void * jarg1, void * jarg2) {
55833   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55834   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
55835
55836   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55837   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
55838   {
55839     try {
55840       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55841     } catch (std::out_of_range& e) {
55842       {
55843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55844       };
55845     } catch (std::exception& e) {
55846       {
55847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55848       };
55849     } catch (Dali::DaliException e) {
55850       {
55851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55852       };
55853     } catch (...) {
55854       {
55855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55856       };
55857     }
55858   }
55859
55860 }
55861
55862
55863 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55864   unsigned int jresult ;
55865   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55866   Dali::Actor arg2 ;
55867   Dali::WheelEvent *arg3 = 0 ;
55868   Dali::Actor *argp2 ;
55869   bool result;
55870
55871   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55872   argp2 = (Dali::Actor *)jarg2;
55873   if (!argp2) {
55874     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55875     return 0;
55876   }
55877   arg2 = *argp2;
55878   arg3 = (Dali::WheelEvent *)jarg3;
55879   if (!arg3) {
55880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
55881     return 0;
55882   }
55883   {
55884     try {
55885       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::WheelEvent const &)*arg3);
55886     } catch (std::out_of_range& e) {
55887       {
55888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55889       };
55890     } catch (std::exception& e) {
55891       {
55892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55893       };
55894     } catch (Dali::DaliException e) {
55895       {
55896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55897       };
55898     } catch (...) {
55899       {
55900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55901       };
55902     }
55903   }
55904
55905   jresult = result;
55906   return jresult;
55907 }
55908
55909
55910 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorWheelSignal() {
55911   void * jresult ;
55912   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *result = 0 ;
55913
55914   {
55915     try {
55916       result = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) >();
55917     } catch (std::out_of_range& e) {
55918       {
55919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55920       };
55921     } catch (std::exception& e) {
55922       {
55923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55924       };
55925     } catch (Dali::DaliException e) {
55926       {
55927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55928       };
55929     } catch (...) {
55930       {
55931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55932       };
55933     }
55934   }
55935
55936   jresult = (void *)result;
55937   return jresult;
55938 }
55939
55940
55941 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorWheelSignal(void * jarg1) {
55942   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55943
55944   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55945   {
55946     try {
55947       delete arg1;
55948     } catch (std::out_of_range& e) {
55949       {
55950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55951       };
55952     } catch (std::exception& e) {
55953       {
55954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55955       };
55956     } catch (Dali::DaliException e) {
55957       {
55958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55959       };
55960     } catch (...) {
55961       {
55962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55963       };
55964     }
55965   }
55966
55967 }
55968
55969
55970 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorSignal_Empty(void * jarg1) {
55971   unsigned int jresult ;
55972   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
55973   bool result;
55974
55975   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
55976   {
55977     try {
55978       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor) > const *)arg1);
55979     } catch (std::out_of_range& e) {
55980       {
55981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55982       };
55983     } catch (std::exception& e) {
55984       {
55985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55986       };
55987     } catch (Dali::DaliException e) {
55988       {
55989         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55990       };
55991     } catch (...) {
55992       {
55993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55994       };
55995     }
55996   }
55997
55998   jresult = result;
55999   return jresult;
56000 }
56001
56002
56003 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorSignal_GetConnectionCount(void * jarg1) {
56004   unsigned long jresult ;
56005   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56006   std::size_t result;
56007
56008   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56009   {
56010     try {
56011       result = Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor) > const *)arg1);
56012     } catch (std::out_of_range& e) {
56013       {
56014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56015       };
56016     } catch (std::exception& e) {
56017       {
56018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56019       };
56020     } catch (Dali::DaliException e) {
56021       {
56022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56023       };
56024     } catch (...) {
56025       {
56026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56027       };
56028     }
56029   }
56030
56031   jresult = (unsigned long)result;
56032   return jresult;
56033 }
56034
56035
56036 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Connect(void * jarg1, void * jarg2) {
56037   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56038   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
56039
56040   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56041   arg2 = (void (*)(Dali::Actor))jarg2;
56042   {
56043     try {
56044       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(arg1,arg2);
56045     } catch (std::out_of_range& e) {
56046       {
56047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56048       };
56049     } catch (std::exception& e) {
56050       {
56051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56052       };
56053     } catch (Dali::DaliException e) {
56054       {
56055         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56056       };
56057     } catch (...) {
56058       {
56059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56060       };
56061     }
56062   }
56063
56064 }
56065
56066
56067 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Disconnect(void * jarg1, void * jarg2) {
56068   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56069   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
56070
56071   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56072   arg2 = (void (*)(Dali::Actor))jarg2;
56073   {
56074     try {
56075       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
56076     } catch (std::out_of_range& e) {
56077       {
56078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56079       };
56080     } catch (std::exception& e) {
56081       {
56082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56083       };
56084     } catch (Dali::DaliException e) {
56085       {
56086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56087       };
56088     } catch (...) {
56089       {
56090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56091       };
56092     }
56093   }
56094
56095 }
56096
56097
56098 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Emit(void * jarg1, void * jarg2) {
56099   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56100   Dali::Actor arg2 ;
56101   Dali::Actor *argp2 ;
56102
56103   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56104   argp2 = (Dali::Actor *)jarg2;
56105   if (!argp2) {
56106     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
56107     return ;
56108   }
56109   arg2 = *argp2;
56110   {
56111     try {
56112       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(arg1,arg2);
56113     } catch (std::out_of_range& e) {
56114       {
56115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56116       };
56117     } catch (std::exception& e) {
56118       {
56119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56120       };
56121     } catch (Dali::DaliException e) {
56122       {
56123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56124       };
56125     } catch (...) {
56126       {
56127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56128       };
56129     }
56130   }
56131
56132 }
56133
56134
56135 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorSignal() {
56136   void * jresult ;
56137   Dali::Signal< void (Dali::Actor) > *result = 0 ;
56138
56139   {
56140     try {
56141       result = (Dali::Signal< void (Dali::Actor) > *)new Dali::Signal< void (Dali::Actor) >();
56142     } catch (std::out_of_range& e) {
56143       {
56144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56145       };
56146     } catch (std::exception& e) {
56147       {
56148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56149       };
56150     } catch (Dali::DaliException e) {
56151       {
56152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56153       };
56154     } catch (...) {
56155       {
56156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56157       };
56158     }
56159   }
56160
56161   jresult = (void *)result;
56162   return jresult;
56163 }
56164
56165
56166 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorSignal(void * jarg1) {
56167   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56168
56169   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56170   {
56171     try {
56172       delete arg1;
56173     } catch (std::out_of_range& e) {
56174       {
56175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56176       };
56177     } catch (std::exception& e) {
56178       {
56179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56180       };
56181     } catch (Dali::DaliException e) {
56182       {
56183         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56184       };
56185     } catch (...) {
56186       {
56187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56188       };
56189     }
56190   }
56191
56192 }
56193
56194
56195 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyEventSignal_Empty(void * jarg1) {
56196   unsigned int jresult ;
56197   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56198   bool result;
56199
56200   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56201   {
56202     try {
56203       result = (bool)Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
56204     } catch (std::out_of_range& e) {
56205       {
56206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56207       };
56208     } catch (std::exception& e) {
56209       {
56210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56211       };
56212     } catch (Dali::DaliException e) {
56213       {
56214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56215       };
56216     } catch (...) {
56217       {
56218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56219       };
56220     }
56221   }
56222
56223   jresult = result;
56224   return jresult;
56225 }
56226
56227
56228 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyEventSignal_GetConnectionCount(void * jarg1) {
56229   unsigned long jresult ;
56230   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56231   std::size_t result;
56232
56233   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56234   {
56235     try {
56236       result = Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
56237     } catch (std::out_of_range& e) {
56238       {
56239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56240       };
56241     } catch (std::exception& e) {
56242       {
56243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56244       };
56245     } catch (Dali::DaliException e) {
56246       {
56247         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56248       };
56249     } catch (...) {
56250       {
56251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56252       };
56253     }
56254   }
56255
56256   jresult = (unsigned long)result;
56257   return jresult;
56258 }
56259
56260
56261 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Connect(void * jarg1, void * jarg2) {
56262   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56263   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
56264
56265   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56266   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
56267   {
56268     try {
56269       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
56270     } catch (std::out_of_range& e) {
56271       {
56272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56273       };
56274     } catch (std::exception& e) {
56275       {
56276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56277       };
56278     } catch (Dali::DaliException e) {
56279       {
56280         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56281       };
56282     } catch (...) {
56283       {
56284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56285       };
56286     }
56287   }
56288
56289 }
56290
56291
56292 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Disconnect(void * jarg1, void * jarg2) {
56293   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56294   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
56295
56296   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56297   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
56298   {
56299     try {
56300       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
56301     } catch (std::out_of_range& e) {
56302       {
56303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56304       };
56305     } catch (std::exception& e) {
56306       {
56307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56308       };
56309     } catch (Dali::DaliException e) {
56310       {
56311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56312       };
56313     } catch (...) {
56314       {
56315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56316       };
56317     }
56318   }
56319
56320 }
56321
56322
56323 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Emit(void * jarg1, void * jarg2) {
56324   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56325   Dali::KeyEvent *arg2 = 0 ;
56326
56327   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56328   arg2 = (Dali::KeyEvent *)jarg2;
56329   if (!arg2) {
56330     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
56331     return ;
56332   }
56333   {
56334     try {
56335       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::KeyEvent const &)*arg2);
56336     } catch (std::out_of_range& e) {
56337       {
56338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56339       };
56340     } catch (std::exception& e) {
56341       {
56342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56343       };
56344     } catch (Dali::DaliException e) {
56345       {
56346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56347       };
56348     } catch (...) {
56349       {
56350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56351       };
56352     }
56353   }
56354
56355 }
56356
56357
56358 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyEventSignal() {
56359   void * jresult ;
56360   Dali::Signal< void (Dali::KeyEvent const &) > *result = 0 ;
56361
56362   {
56363     try {
56364       result = (Dali::Signal< void (Dali::KeyEvent const &) > *)new Dali::Signal< void (Dali::KeyEvent const &) >();
56365     } catch (std::out_of_range& e) {
56366       {
56367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56368       };
56369     } catch (std::exception& e) {
56370       {
56371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56372       };
56373     } catch (Dali::DaliException e) {
56374       {
56375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56376       };
56377     } catch (...) {
56378       {
56379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56380       };
56381     }
56382   }
56383
56384   jresult = (void *)result;
56385   return jresult;
56386 }
56387
56388
56389 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyEventSignal(void * jarg1) {
56390   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56391
56392   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56393   {
56394     try {
56395       delete arg1;
56396     } catch (std::out_of_range& e) {
56397       {
56398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56399       };
56400     } catch (std::exception& e) {
56401       {
56402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56403       };
56404     } catch (Dali::DaliException e) {
56405       {
56406         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56407       };
56408     } catch (...) {
56409       {
56410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56411       };
56412     }
56413   }
56414
56415 }
56416
56417
56418 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TouchSignal_Empty(void * jarg1) {
56419   unsigned int jresult ;
56420   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56421   bool result;
56422
56423   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56424   {
56425     try {
56426       result = (bool)Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
56427     } catch (std::out_of_range& e) {
56428       {
56429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56430       };
56431     } catch (std::exception& e) {
56432       {
56433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56434       };
56435     } catch (Dali::DaliException e) {
56436       {
56437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56438       };
56439     } catch (...) {
56440       {
56441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56442       };
56443     }
56444   }
56445
56446   jresult = result;
56447   return jresult;
56448 }
56449
56450
56451 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchSignal_GetConnectionCount(void * jarg1) {
56452   unsigned long jresult ;
56453   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56454   std::size_t result;
56455
56456   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56457   {
56458     try {
56459       result = Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
56460     } catch (std::out_of_range& e) {
56461       {
56462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56463       };
56464     } catch (std::exception& e) {
56465       {
56466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56467       };
56468     } catch (Dali::DaliException e) {
56469       {
56470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56471       };
56472     } catch (...) {
56473       {
56474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56475       };
56476     }
56477   }
56478
56479   jresult = (unsigned long)result;
56480   return jresult;
56481 }
56482
56483
56484 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Connect(void * jarg1, void * jarg2) {
56485   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56486   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
56487
56488   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56489   arg2 = (void (*)(Dali::TouchData const &))jarg2;
56490   {
56491     try {
56492       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
56493     } catch (std::out_of_range& e) {
56494       {
56495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56496       };
56497     } catch (std::exception& e) {
56498       {
56499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56500       };
56501     } catch (Dali::DaliException e) {
56502       {
56503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56504       };
56505     } catch (...) {
56506       {
56507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56508       };
56509     }
56510   }
56511
56512 }
56513
56514
56515 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Disconnect(void * jarg1, void * jarg2) {
56516   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56517   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
56518
56519   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56520   arg2 = (void (*)(Dali::TouchData const &))jarg2;
56521   {
56522     try {
56523       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
56524     } catch (std::out_of_range& e) {
56525       {
56526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56527       };
56528     } catch (std::exception& e) {
56529       {
56530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56531       };
56532     } catch (Dali::DaliException e) {
56533       {
56534         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56535       };
56536     } catch (...) {
56537       {
56538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56539       };
56540     }
56541   }
56542
56543 }
56544
56545
56546 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Emit(void * jarg1, void * jarg2) {
56547   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56548   Dali::TouchData *arg2 = 0 ;
56549
56550   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56551   arg2 = (Dali::TouchData *)jarg2;
56552   if (!arg2) {
56553     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
56554     return ;
56555   }
56556   {
56557     try {
56558       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,(Dali::TouchData const &)*arg2);
56559     } catch (std::out_of_range& e) {
56560       {
56561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56562       };
56563     } catch (std::exception& e) {
56564       {
56565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56566       };
56567     } catch (Dali::DaliException e) {
56568       {
56569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56570       };
56571     } catch (...) {
56572       {
56573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56574       };
56575     }
56576   }
56577
56578 }
56579
56580
56581 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchSignal() {
56582   void * jresult ;
56583   Dali::Signal< void (Dali::TouchData const &) > *result = 0 ;
56584
56585   {
56586     try {
56587       result = (Dali::Signal< void (Dali::TouchData const &) > *)new Dali::Signal< void (Dali::TouchData const &) >();
56588     } catch (std::out_of_range& e) {
56589       {
56590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56591       };
56592     } catch (std::exception& e) {
56593       {
56594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56595       };
56596     } catch (Dali::DaliException e) {
56597       {
56598         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56599       };
56600     } catch (...) {
56601       {
56602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56603       };
56604     }
56605   }
56606
56607   jresult = (void *)result;
56608   return jresult;
56609 }
56610
56611
56612 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchSignal(void * jarg1) {
56613   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56614
56615   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56616   {
56617     try {
56618       delete arg1;
56619     } catch (std::out_of_range& e) {
56620       {
56621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56622       };
56623     } catch (std::exception& e) {
56624       {
56625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56626       };
56627     } catch (Dali::DaliException e) {
56628       {
56629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56630       };
56631     } catch (...) {
56632       {
56633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56634       };
56635     }
56636   }
56637
56638 }
56639
56640
56641 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StageWheelSignal_Empty(void * jarg1) {
56642   unsigned int jresult ;
56643   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56644   bool result;
56645
56646   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56647   {
56648     try {
56649       result = (bool)Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
56650     } catch (std::out_of_range& e) {
56651       {
56652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56653       };
56654     } catch (std::exception& e) {
56655       {
56656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56657       };
56658     } catch (Dali::DaliException e) {
56659       {
56660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56661       };
56662     } catch (...) {
56663       {
56664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56665       };
56666     }
56667   }
56668
56669   jresult = result;
56670   return jresult;
56671 }
56672
56673
56674 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StageWheelSignal_GetConnectionCount(void * jarg1) {
56675   unsigned long jresult ;
56676   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56677   std::size_t result;
56678
56679   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56680   {
56681     try {
56682       result = Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
56683     } catch (std::out_of_range& e) {
56684       {
56685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56686       };
56687     } catch (std::exception& e) {
56688       {
56689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56690       };
56691     } catch (Dali::DaliException e) {
56692       {
56693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56694       };
56695     } catch (...) {
56696       {
56697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56698       };
56699     }
56700   }
56701
56702   jresult = (unsigned long)result;
56703   return jresult;
56704 }
56705
56706
56707 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Connect(void * jarg1, void * jarg2) {
56708   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56709   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
56710
56711   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56712   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
56713   {
56714     try {
56715       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
56716     } catch (std::out_of_range& e) {
56717       {
56718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56719       };
56720     } catch (std::exception& e) {
56721       {
56722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56723       };
56724     } catch (Dali::DaliException e) {
56725       {
56726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56727       };
56728     } catch (...) {
56729       {
56730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56731       };
56732     }
56733   }
56734
56735 }
56736
56737
56738 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Disconnect(void * jarg1, void * jarg2) {
56739   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56740   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
56741
56742   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56743   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
56744   {
56745     try {
56746       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
56747     } catch (std::out_of_range& e) {
56748       {
56749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56750       };
56751     } catch (std::exception& e) {
56752       {
56753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56754       };
56755     } catch (Dali::DaliException e) {
56756       {
56757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56758       };
56759     } catch (...) {
56760       {
56761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56762       };
56763     }
56764   }
56765
56766 }
56767
56768
56769 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Emit(void * jarg1, void * jarg2) {
56770   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56771   Dali::WheelEvent *arg2 = 0 ;
56772
56773   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56774   arg2 = (Dali::WheelEvent *)jarg2;
56775   if (!arg2) {
56776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
56777     return ;
56778   }
56779   {
56780     try {
56781       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::WheelEvent const &)*arg2);
56782     } catch (std::out_of_range& e) {
56783       {
56784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56785       };
56786     } catch (std::exception& e) {
56787       {
56788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56789       };
56790     } catch (Dali::DaliException e) {
56791       {
56792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56793       };
56794     } catch (...) {
56795       {
56796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56797       };
56798     }
56799   }
56800
56801 }
56802
56803
56804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StageWheelSignal() {
56805   void * jresult ;
56806   Dali::Signal< void (Dali::WheelEvent const &) > *result = 0 ;
56807
56808   {
56809     try {
56810       result = (Dali::Signal< void (Dali::WheelEvent const &) > *)new Dali::Signal< void (Dali::WheelEvent const &) >();
56811     } catch (std::out_of_range& e) {
56812       {
56813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56814       };
56815     } catch (std::exception& e) {
56816       {
56817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56818       };
56819     } catch (Dali::DaliException e) {
56820       {
56821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56822       };
56823     } catch (...) {
56824       {
56825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56826       };
56827     }
56828   }
56829
56830   jresult = (void *)result;
56831   return jresult;
56832 }
56833
56834
56835 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StageWheelSignal(void * jarg1) {
56836   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56837
56838   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56839   {
56840     try {
56841       delete arg1;
56842     } catch (std::out_of_range& e) {
56843       {
56844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56845       };
56846     } catch (std::exception& e) {
56847       {
56848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56849       };
56850     } catch (Dali::DaliException e) {
56851       {
56852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56853       };
56854     } catch (...) {
56855       {
56856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56857       };
56858     }
56859   }
56860
56861 }
56862
56863
56864 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_0() {
56865   void * jresult ;
56866   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
56867
56868   {
56869     try {
56870       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >();
56871     } catch (std::out_of_range& e) {
56872       {
56873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56874       };
56875     } catch (std::exception& e) {
56876       {
56877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56878       };
56879     } catch (Dali::DaliException e) {
56880       {
56881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56882       };
56883     } catch (...) {
56884       {
56885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56886       };
56887     }
56888   }
56889
56890   jresult = (void *)result;
56891   return jresult;
56892 }
56893
56894
56895 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_1(void * jarg1, void * jarg2) {
56896   void * jresult ;
56897   Dali::Radian arg1 ;
56898   Dali::Radian arg2 ;
56899   Dali::Radian *argp1 ;
56900   Dali::Radian *argp2 ;
56901   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
56902
56903   argp1 = (Dali::Radian *)jarg1;
56904   if (!argp1) {
56905     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
56906     return 0;
56907   }
56908   arg1 = *argp1;
56909   argp2 = (Dali::Radian *)jarg2;
56910   if (!argp2) {
56911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
56912     return 0;
56913   }
56914   arg2 = *argp2;
56915   {
56916     try {
56917       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >(arg1,arg2);
56918     } catch (std::out_of_range& e) {
56919       {
56920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56921       };
56922     } catch (std::exception& e) {
56923       {
56924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56925       };
56926     } catch (Dali::DaliException e) {
56927       {
56928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56929       };
56930     } catch (...) {
56931       {
56932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56933       };
56934     }
56935   }
56936
56937   jresult = (void *)result;
56938   return jresult;
56939 }
56940
56941
56942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_2(void * jarg1) {
56943   void * jresult ;
56944   std::pair< Dali::Radian,Dali::Radian > *arg1 = 0 ;
56945   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
56946
56947   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
56948   if (!arg1) {
56949     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< Dali::Radian,Dali::Radian > const & type is null", 0);
56950     return 0;
56951   }
56952   {
56953     try {
56954       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >((std::pair< Dali::Radian,Dali::Radian > const &)*arg1);
56955     } catch (std::out_of_range& e) {
56956       {
56957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56958       };
56959     } catch (std::exception& e) {
56960       {
56961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56962       };
56963     } catch (Dali::DaliException e) {
56964       {
56965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56966       };
56967     } catch (...) {
56968       {
56969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56970       };
56971     }
56972   }
56973
56974   jresult = (void *)result;
56975   return jresult;
56976 }
56977
56978
56979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_set(void * jarg1, void * jarg2) {
56980   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
56981   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
56982
56983   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
56984   arg2 = (Dali::Radian *)jarg2;
56985   if (arg1) (arg1)->first = *arg2;
56986 }
56987
56988
56989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_get(void * jarg1) {
56990   void * jresult ;
56991   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
56992   Dali::Radian *result = 0 ;
56993
56994   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
56995   result = (Dali::Radian *)& ((arg1)->first);
56996   jresult = (void *)result;
56997   return jresult;
56998 }
56999
57000
57001 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_set(void * jarg1, void * jarg2) {
57002   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
57003   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
57004
57005   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57006   arg2 = (Dali::Radian *)jarg2;
57007   if (arg1) (arg1)->second = *arg2;
57008 }
57009
57010
57011 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_get(void * jarg1) {
57012   void * jresult ;
57013   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
57014   Dali::Radian *result = 0 ;
57015
57016   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57017   result = (Dali::Radian *)& ((arg1)->second);
57018   jresult = (void *)result;
57019   return jresult;
57020 }
57021
57022
57023 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleThresholdPair(void * jarg1) {
57024   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
57025
57026   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57027   {
57028     try {
57029       delete arg1;
57030     } catch (std::out_of_range& e) {
57031       {
57032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57033       };
57034     } catch (std::exception& e) {
57035       {
57036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57037       };
57038     } catch (Dali::DaliException e) {
57039       {
57040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57041       };
57042     } catch (...) {
57043       {
57044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57045       };
57046     }
57047   }
57048
57049 }
57050
57051
57052 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Empty(void * jarg1) {
57053   unsigned int jresult ;
57054   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57055   bool result;
57056
57057   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57058   {
57059     try {
57060       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);
57061     } catch (std::out_of_range& e) {
57062       {
57063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57064       };
57065     } catch (std::exception& e) {
57066       {
57067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57068       };
57069     } catch (Dali::DaliException e) {
57070       {
57071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57072       };
57073     } catch (...) {
57074       {
57075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57076       };
57077     }
57078   }
57079
57080   jresult = result;
57081   return jresult;
57082 }
57083
57084
57085 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_GetConnectionCount(void * jarg1) {
57086   unsigned long jresult ;
57087   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57088   std::size_t result;
57089
57090   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57091   {
57092     try {
57093       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);
57094     } catch (std::out_of_range& e) {
57095       {
57096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57097       };
57098     } catch (std::exception& e) {
57099       {
57100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57101       };
57102     } catch (Dali::DaliException e) {
57103       {
57104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57105       };
57106     } catch (...) {
57107       {
57108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57109       };
57110     }
57111   }
57112
57113   jresult = (unsigned long)result;
57114   return jresult;
57115 }
57116
57117
57118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
57119   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57120   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
57121
57122   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57123   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
57124   {
57125     try {
57126       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
57127     } catch (std::out_of_range& e) {
57128       {
57129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57130       };
57131     } catch (std::exception& e) {
57132       {
57133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57134       };
57135     } catch (Dali::DaliException e) {
57136       {
57137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57138       };
57139     } catch (...) {
57140       {
57141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57142       };
57143     }
57144   }
57145
57146 }
57147
57148
57149 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
57150   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57151   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
57152
57153   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57154   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
57155   {
57156     try {
57157       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
57158     } catch (std::out_of_range& e) {
57159       {
57160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57161       };
57162     } catch (std::exception& e) {
57163       {
57164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57165       };
57166     } catch (Dali::DaliException e) {
57167       {
57168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57169       };
57170     } catch (...) {
57171       {
57172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57173       };
57174     }
57175   }
57176
57177 }
57178
57179
57180 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
57181   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57182   Dali::Actor arg2 ;
57183   Dali::PanGesture *arg3 = 0 ;
57184   Dali::Actor *argp2 ;
57185
57186   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57187   argp2 = (Dali::Actor *)jarg2;
57188   if (!argp2) {
57189     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57190     return ;
57191   }
57192   arg2 = *argp2;
57193   arg3 = (Dali::PanGesture *)jarg3;
57194   if (!arg3) {
57195     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
57196     return ;
57197   }
57198   {
57199     try {
57200       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PanGesture const &)*arg3);
57201     } catch (std::out_of_range& e) {
57202       {
57203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57204       };
57205     } catch (std::exception& e) {
57206       {
57207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57208       };
57209     } catch (Dali::DaliException e) {
57210       {
57211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57212       };
57213     } catch (...) {
57214       {
57215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57216       };
57217     }
57218   }
57219
57220 }
57221
57222
57223 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetectedSignal() {
57224   void * jresult ;
57225   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *result = 0 ;
57226
57227   {
57228     try {
57229       result = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) >();
57230     } catch (std::out_of_range& e) {
57231       {
57232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57233       };
57234     } catch (std::exception& e) {
57235       {
57236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57237       };
57238     } catch (Dali::DaliException e) {
57239       {
57240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57241       };
57242     } catch (...) {
57243       {
57244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57245       };
57246     }
57247   }
57248
57249   jresult = (void *)result;
57250   return jresult;
57251 }
57252
57253
57254 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetectedSignal(void * jarg1) {
57255   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57256
57257   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57258   {
57259     try {
57260       delete arg1;
57261     } catch (std::out_of_range& e) {
57262       {
57263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57264       };
57265     } catch (std::exception& e) {
57266       {
57267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57268       };
57269     } catch (Dali::DaliException e) {
57270       {
57271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57272       };
57273     } catch (...) {
57274       {
57275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57276       };
57277     }
57278   }
57279
57280 }
57281
57282
57283 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Empty(void * jarg1) {
57284   unsigned int jresult ;
57285   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57286   bool result;
57287
57288   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57289   {
57290     try {
57291       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);
57292     } catch (std::out_of_range& e) {
57293       {
57294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57295       };
57296     } catch (std::exception& e) {
57297       {
57298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57299       };
57300     } catch (Dali::DaliException e) {
57301       {
57302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57303       };
57304     } catch (...) {
57305       {
57306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57307       };
57308     }
57309   }
57310
57311   jresult = result;
57312   return jresult;
57313 }
57314
57315
57316 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_GetConnectionCount(void * jarg1) {
57317   unsigned long jresult ;
57318   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57319   std::size_t result;
57320
57321   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57322   {
57323     try {
57324       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);
57325     } catch (std::out_of_range& e) {
57326       {
57327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57328       };
57329     } catch (std::exception& e) {
57330       {
57331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57332       };
57333     } catch (Dali::DaliException e) {
57334       {
57335         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57336       };
57337     } catch (...) {
57338       {
57339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57340       };
57341     }
57342   }
57343
57344   jresult = (unsigned long)result;
57345   return jresult;
57346 }
57347
57348
57349 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
57350   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57351   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
57352
57353   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57354   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
57355   {
57356     try {
57357       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
57358     } catch (std::out_of_range& e) {
57359       {
57360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57361       };
57362     } catch (std::exception& e) {
57363       {
57364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57365       };
57366     } catch (Dali::DaliException e) {
57367       {
57368         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57369       };
57370     } catch (...) {
57371       {
57372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57373       };
57374     }
57375   }
57376
57377 }
57378
57379
57380 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
57381   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57382   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
57383
57384   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57385   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
57386   {
57387     try {
57388       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
57389     } catch (std::out_of_range& e) {
57390       {
57391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57392       };
57393     } catch (std::exception& e) {
57394       {
57395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57396       };
57397     } catch (Dali::DaliException e) {
57398       {
57399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57400       };
57401     } catch (...) {
57402       {
57403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57404       };
57405     }
57406   }
57407
57408 }
57409
57410
57411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
57412   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57413   Dali::Actor arg2 ;
57414   Dali::PinchGesture *arg3 = 0 ;
57415   Dali::Actor *argp2 ;
57416
57417   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57418   argp2 = (Dali::Actor *)jarg2;
57419   if (!argp2) {
57420     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57421     return ;
57422   }
57423   arg2 = *argp2;
57424   arg3 = (Dali::PinchGesture *)jarg3;
57425   if (!arg3) {
57426     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
57427     return ;
57428   }
57429   {
57430     try {
57431       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PinchGesture const &)*arg3);
57432     } catch (std::out_of_range& e) {
57433       {
57434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57435       };
57436     } catch (std::exception& e) {
57437       {
57438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57439       };
57440     } catch (Dali::DaliException e) {
57441       {
57442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57443       };
57444     } catch (...) {
57445       {
57446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57447       };
57448     }
57449   }
57450
57451 }
57452
57453
57454 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetectedSignal() {
57455   void * jresult ;
57456   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *result = 0 ;
57457
57458   {
57459     try {
57460       result = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) >();
57461     } catch (std::out_of_range& e) {
57462       {
57463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57464       };
57465     } catch (std::exception& e) {
57466       {
57467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57468       };
57469     } catch (Dali::DaliException e) {
57470       {
57471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57472       };
57473     } catch (...) {
57474       {
57475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57476       };
57477     }
57478   }
57479
57480   jresult = (void *)result;
57481   return jresult;
57482 }
57483
57484
57485 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetectedSignal(void * jarg1) {
57486   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57487
57488   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57489   {
57490     try {
57491       delete arg1;
57492     } catch (std::out_of_range& e) {
57493       {
57494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57495       };
57496     } catch (std::exception& e) {
57497       {
57498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57499       };
57500     } catch (Dali::DaliException e) {
57501       {
57502         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57503       };
57504     } catch (...) {
57505       {
57506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57507       };
57508     }
57509   }
57510
57511 }
57512
57513
57514 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Empty(void * jarg1) {
57515   unsigned int jresult ;
57516   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57517   bool result;
57518
57519   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57520   {
57521     try {
57522       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);
57523     } catch (std::out_of_range& e) {
57524       {
57525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57526       };
57527     } catch (std::exception& e) {
57528       {
57529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57530       };
57531     } catch (Dali::DaliException e) {
57532       {
57533         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57534       };
57535     } catch (...) {
57536       {
57537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57538       };
57539     }
57540   }
57541
57542   jresult = result;
57543   return jresult;
57544 }
57545
57546
57547 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_GetConnectionCount(void * jarg1) {
57548   unsigned long jresult ;
57549   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57550   std::size_t result;
57551
57552   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57553   {
57554     try {
57555       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);
57556     } catch (std::out_of_range& e) {
57557       {
57558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57559       };
57560     } catch (std::exception& e) {
57561       {
57562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57563       };
57564     } catch (Dali::DaliException e) {
57565       {
57566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57567       };
57568     } catch (...) {
57569       {
57570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57571       };
57572     }
57573   }
57574
57575   jresult = (unsigned long)result;
57576   return jresult;
57577 }
57578
57579
57580 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
57581   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57582   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
57583
57584   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57585   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
57586   {
57587     try {
57588       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
57589     } catch (std::out_of_range& e) {
57590       {
57591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57592       };
57593     } catch (std::exception& e) {
57594       {
57595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57596       };
57597     } catch (Dali::DaliException e) {
57598       {
57599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57600       };
57601     } catch (...) {
57602       {
57603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57604       };
57605     }
57606   }
57607
57608 }
57609
57610
57611 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
57612   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57613   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
57614
57615   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57616   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
57617   {
57618     try {
57619       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
57620     } catch (std::out_of_range& e) {
57621       {
57622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57623       };
57624     } catch (std::exception& e) {
57625       {
57626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57627       };
57628     } catch (Dali::DaliException e) {
57629       {
57630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57631       };
57632     } catch (...) {
57633       {
57634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57635       };
57636     }
57637   }
57638
57639 }
57640
57641
57642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
57643   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57644   Dali::Actor arg2 ;
57645   Dali::TapGesture *arg3 = 0 ;
57646   Dali::Actor *argp2 ;
57647
57648   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57649   argp2 = (Dali::Actor *)jarg2;
57650   if (!argp2) {
57651     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57652     return ;
57653   }
57654   arg2 = *argp2;
57655   arg3 = (Dali::TapGesture *)jarg3;
57656   if (!arg3) {
57657     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
57658     return ;
57659   }
57660   {
57661     try {
57662       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TapGesture const &)*arg3);
57663     } catch (std::out_of_range& e) {
57664       {
57665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57666       };
57667     } catch (std::exception& e) {
57668       {
57669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57670       };
57671     } catch (Dali::DaliException e) {
57672       {
57673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57674       };
57675     } catch (...) {
57676       {
57677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57678       };
57679     }
57680   }
57681
57682 }
57683
57684
57685 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetectedSignal() {
57686   void * jresult ;
57687   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *result = 0 ;
57688
57689   {
57690     try {
57691       result = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) >();
57692     } catch (std::out_of_range& e) {
57693       {
57694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57695       };
57696     } catch (std::exception& e) {
57697       {
57698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57699       };
57700     } catch (Dali::DaliException e) {
57701       {
57702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57703       };
57704     } catch (...) {
57705       {
57706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57707       };
57708     }
57709   }
57710
57711   jresult = (void *)result;
57712   return jresult;
57713 }
57714
57715
57716 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetectedSignal(void * jarg1) {
57717   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57718
57719   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57720   {
57721     try {
57722       delete arg1;
57723     } catch (std::out_of_range& e) {
57724       {
57725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57726       };
57727     } catch (std::exception& e) {
57728       {
57729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57730       };
57731     } catch (Dali::DaliException e) {
57732       {
57733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57734       };
57735     } catch (...) {
57736       {
57737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57738       };
57739     }
57740   }
57741
57742 }
57743
57744 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Empty(void * jarg1) {
57745   unsigned int jresult ;
57746   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57747   bool result;
57748
57749   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57750   {
57751     try {
57752       result = (bool)Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
57753     } catch (std::out_of_range& e) {
57754       {
57755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57756       };
57757     } catch (std::exception& e) {
57758       {
57759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57760       };
57761     } catch (Dali::DaliException e) {
57762       {
57763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57764       };
57765     } catch (...) {
57766       {
57767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57768       };
57769     }
57770   }
57771
57772   jresult = result;
57773   return jresult;
57774 }
57775
57776
57777 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ResourceImageSignal_GetConnectionCount(void * jarg1) {
57778   unsigned long jresult ;
57779   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57780   std::size_t result;
57781
57782   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57783   {
57784     try {
57785       result = Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
57786     } catch (std::out_of_range& e) {
57787       {
57788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57789       };
57790     } catch (std::exception& e) {
57791       {
57792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57793       };
57794     } catch (Dali::DaliException e) {
57795       {
57796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57797       };
57798     } catch (...) {
57799       {
57800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57801       };
57802     }
57803   }
57804
57805   jresult = (unsigned long)result;
57806   return jresult;
57807 }
57808
57809
57810 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Connect(void * jarg1, void * jarg2) {
57811   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57812   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
57813
57814   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57815   arg2 = (void (*)(Dali::ResourceImage))jarg2;
57816   {
57817     try {
57818       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(arg1,arg2);
57819     } catch (std::out_of_range& e) {
57820       {
57821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57822       };
57823     } catch (std::exception& e) {
57824       {
57825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57826       };
57827     } catch (Dali::DaliException e) {
57828       {
57829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57830       };
57831     } catch (...) {
57832       {
57833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57834       };
57835     }
57836   }
57837
57838 }
57839
57840
57841 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Disconnect(void * jarg1, void * jarg2) {
57842   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57843   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
57844
57845   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57846   arg2 = (void (*)(Dali::ResourceImage))jarg2;
57847   {
57848     try {
57849       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(arg1,arg2);
57850     } catch (std::out_of_range& e) {
57851       {
57852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57853       };
57854     } catch (std::exception& e) {
57855       {
57856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57857       };
57858     } catch (Dali::DaliException e) {
57859       {
57860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57861       };
57862     } catch (...) {
57863       {
57864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57865       };
57866     }
57867   }
57868
57869 }
57870
57871
57872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Emit(void * jarg1, void * jarg2) {
57873   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57874   Dali::ResourceImage arg2 ;
57875   Dali::ResourceImage *argp2 ;
57876
57877   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57878   argp2 = (Dali::ResourceImage *)jarg2;
57879   if (!argp2) {
57880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ResourceImage", 0);
57881     return ;
57882   }
57883   arg2 = *argp2;
57884   {
57885     try {
57886       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(arg1,arg2);
57887     } catch (std::out_of_range& e) {
57888       {
57889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57890       };
57891     } catch (std::exception& e) {
57892       {
57893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57894       };
57895     } catch (Dali::DaliException e) {
57896       {
57897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57898       };
57899     } catch (...) {
57900       {
57901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57902       };
57903     }
57904   }
57905
57906 }
57907
57908
57909 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImageSignal() {
57910   void * jresult ;
57911   Dali::Signal< void (Dali::ResourceImage) > *result = 0 ;
57912
57913   {
57914     try {
57915       result = (Dali::Signal< void (Dali::ResourceImage) > *)new Dali::Signal< void (Dali::ResourceImage) >();
57916     } catch (std::out_of_range& e) {
57917       {
57918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57919       };
57920     } catch (std::exception& e) {
57921       {
57922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57923       };
57924     } catch (Dali::DaliException e) {
57925       {
57926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57927       };
57928     } catch (...) {
57929       {
57930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57931       };
57932     }
57933   }
57934
57935   jresult = (void *)result;
57936   return jresult;
57937 }
57938
57939
57940 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImageSignal(void * jarg1) {
57941   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57942
57943   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57944   {
57945     try {
57946       delete arg1;
57947     } catch (std::out_of_range& e) {
57948       {
57949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57950       };
57951     } catch (std::exception& e) {
57952       {
57953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57954       };
57955     } catch (Dali::DaliException e) {
57956       {
57957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57958       };
57959     } catch (...) {
57960       {
57961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57962       };
57963     }
57964   }
57965
57966 }
57967
57968 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionChangedSignal_Empty(void * jarg1) {
57969   unsigned int jresult ;
57970   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
57971   bool result = false;
57972
57973   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
57974   {
57975     try {
57976       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);
57977     } catch (std::out_of_range& e) {
57978       {
57979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57980       };
57981     } catch (std::exception& e) {
57982       {
57983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57984       };
57985     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
57986   }
57987   jresult = result;
57988   return jresult;
57989 }
57990
57991 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_GetConnectionCount(void * jarg1) {
57992   unsigned long jresult ;
57993   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
57994   std::size_t result = 0;
57995
57996   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
57997   {
57998     try {
57999       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);
58000     } catch (std::out_of_range& e) {
58001       {
58002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58003       };
58004     } catch (std::exception& e) {
58005       {
58006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58007       };
58008     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58009   }
58010   jresult = (unsigned long)result;
58011   return jresult;
58012 }
58013
58014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Connect(void * jarg1, void * jarg2) {
58015   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58016   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
58017
58018   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58019   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
58020   {
58021     try {
58022       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Connect(arg1,arg2);
58023     } catch (std::out_of_range& e) {
58024       {
58025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58026       };
58027     } catch (std::exception& e) {
58028       {
58029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58030       };
58031     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58032   }
58033 }
58034
58035 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Disconnect(void * jarg1, void * jarg2) {
58036   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58037   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
58038
58039   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58040   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
58041   {
58042     try {
58043       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Disconnect(arg1,arg2);
58044     } catch (std::out_of_range& e) {
58045       {
58046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58047       };
58048     } catch (std::exception& e) {
58049       {
58050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58051       };
58052     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58053   }
58054 }
58055
58056 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Emit(void * jarg1, void * jarg2, int jarg4) {
58057   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58058   Dali::Actor arg2 ;
58059   //bool arg3 ;
58060   Dali::LayoutDirection::Type arg4 ;
58061   Dali::Actor *argp2 ;
58062
58063   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58064   argp2 = (Dali::Actor *)jarg2;
58065   if (!argp2) {
58066     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58067     return ;
58068   }
58069   arg2 = *argp2;
58070   //arg3 = jarg3 ? true : false;
58071   arg4 = (Dali::LayoutDirection::Type)jarg4;
58072   {
58073     try {
58074       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Emit(arg1,arg2,arg4);
58075     } catch (std::out_of_range& e) {
58076       {
58077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58078       };
58079     } catch (std::exception& e) {
58080       {
58081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58082       };
58083     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58084   }
58085 }
58086
58087 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewLayoutDirectionSignal() {
58088   void * jresult ;
58089   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *result = 0 ;
58090
58091   {
58092     try {
58093       result = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)new Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) >();
58094     } catch (std::out_of_range& e) {
58095       {
58096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58097       };
58098     } catch (std::exception& e) {
58099       {
58100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58101       };
58102     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58103   }
58104   jresult = (void *)result;
58105   return jresult;
58106 }
58107
58108 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewLayoutDirectionSignal(void * jarg1) {
58109   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58110
58111   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58112   {
58113     try {
58114       delete arg1;
58115     } catch (std::out_of_range& e) {
58116       {
58117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58118       };
58119     } catch (std::exception& e) {
58120       {
58121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58122       };
58123     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58124   }
58125 }
58126
58127 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Empty(void * jarg1) {
58128   unsigned int jresult ;
58129   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58130   bool result;
58131
58132   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58133   {
58134     try {
58135       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);
58136     } catch (std::out_of_range& e) {
58137       {
58138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58139       };
58140     } catch (std::exception& e) {
58141       {
58142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58143       };
58144     } catch (Dali::DaliException e) {
58145       {
58146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58147       };
58148     } catch (...) {
58149       {
58150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58151       };
58152     }
58153   }
58154
58155   jresult = result;
58156   return jresult;
58157 }
58158
58159
58160 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_GetConnectionCount(void * jarg1) {
58161   unsigned long jresult ;
58162   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58163   std::size_t result;
58164
58165   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58166   {
58167     try {
58168       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);
58169     } catch (std::out_of_range& e) {
58170       {
58171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58172       };
58173     } catch (std::exception& e) {
58174       {
58175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58176       };
58177     } catch (Dali::DaliException e) {
58178       {
58179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58180       };
58181     } catch (...) {
58182       {
58183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58184       };
58185     }
58186   }
58187
58188   jresult = (unsigned long)result;
58189   return jresult;
58190 }
58191
58192
58193 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Connect(void * jarg1, void * jarg2) {
58194   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58195   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
58196
58197   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58198   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
58199   {
58200     try {
58201       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Connect(arg1,arg2);
58202     } catch (std::out_of_range& e) {
58203       {
58204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58205       };
58206     } catch (std::exception& e) {
58207       {
58208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58209       };
58210     } catch (Dali::DaliException e) {
58211       {
58212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58213       };
58214     } catch (...) {
58215       {
58216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58217       };
58218     }
58219   }
58220
58221 }
58222
58223
58224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Disconnect(void * jarg1, void * jarg2) {
58225   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58226   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
58227
58228   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58229   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
58230   {
58231     try {
58232       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Disconnect(arg1,arg2);
58233     } catch (std::out_of_range& e) {
58234       {
58235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58236       };
58237     } catch (std::exception& e) {
58238       {
58239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58240       };
58241     } catch (Dali::DaliException e) {
58242       {
58243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58244       };
58245     } catch (...) {
58246       {
58247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58248       };
58249     }
58250   }
58251
58252 }
58253
58254
58255 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, int jarg4) {
58256   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58257   Dali::Actor arg2 ;
58258   bool arg3 ;
58259   Dali::DevelActor::VisibilityChange::Type arg4 ;
58260   Dali::Actor *argp2 ;
58261
58262   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58263   argp2 = (Dali::Actor *)jarg2;
58264   if (!argp2) {
58265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58266     return ;
58267   }
58268   arg2 = *argp2;
58269   arg3 = jarg3 ? true : false;
58270   arg4 = (Dali::DevelActor::VisibilityChange::Type)jarg4;
58271   {
58272     try {
58273       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Emit(arg1,arg2,arg3,arg4);
58274     } catch (std::out_of_range& e) {
58275       {
58276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58277       };
58278     } catch (std::exception& e) {
58279       {
58280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58281       };
58282     } catch (Dali::DaliException e) {
58283       {
58284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58285       };
58286     } catch (...) {
58287       {
58288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58289       };
58290     }
58291   }
58292
58293 }
58294
58295
58296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewVisibilityChangedSignal() {
58297   void * jresult ;
58298   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *result = 0 ;
58299
58300   {
58301     try {
58302       result = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)new Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) >();
58303     } catch (std::out_of_range& e) {
58304       {
58305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58306       };
58307     } catch (std::exception& e) {
58308       {
58309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58310       };
58311     } catch (Dali::DaliException e) {
58312       {
58313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58314       };
58315     } catch (...) {
58316       {
58317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58318       };
58319     }
58320   }
58321
58322   jresult = (void *)result;
58323   return jresult;
58324 }
58325
58326
58327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewVisibilityChangedSignal(void * jarg1) {
58328   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58329
58330   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58331   {
58332     try {
58333       delete arg1;
58334     } catch (std::out_of_range& e) {
58335       {
58336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58337       };
58338     } catch (std::exception& e) {
58339       {
58340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58341       };
58342     } catch (Dali::DaliException e) {
58343       {
58344         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58345       };
58346     } catch (...) {
58347       {
58348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58349       };
58350     }
58351   }
58352
58353 }
58354
58355
58356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_0() {
58357   void * jresult ;
58358   Dali::Timer *result = 0 ;
58359
58360   {
58361     try {
58362       result = (Dali::Timer *)new Dali::Timer();
58363     } catch (std::out_of_range& e) {
58364       {
58365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58366       };
58367     } catch (std::exception& e) {
58368       {
58369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58370       };
58371     } catch (Dali::DaliException e) {
58372       {
58373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58374       };
58375     } catch (...) {
58376       {
58377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58378       };
58379     }
58380   }
58381
58382   jresult = (void *)result;
58383   return jresult;
58384 }
58385
58386
58387 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_New(unsigned int jarg1) {
58388   void * jresult ;
58389   unsigned int arg1 ;
58390   Dali::Timer result;
58391
58392   arg1 = (unsigned int)jarg1;
58393   {
58394     try {
58395       result = Dali::Timer::New(arg1);
58396     } catch (std::out_of_range& e) {
58397       {
58398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58399       };
58400     } catch (std::exception& e) {
58401       {
58402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58403       };
58404     } catch (Dali::DaliException e) {
58405       {
58406         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58407       };
58408     } catch (...) {
58409       {
58410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58411       };
58412     }
58413   }
58414
58415   jresult = new Dali::Timer((const Dali::Timer &)result);
58416   return jresult;
58417 }
58418
58419
58420 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_1(void * jarg1) {
58421   void * jresult ;
58422   Dali::Timer *arg1 = 0 ;
58423   Dali::Timer *result = 0 ;
58424
58425   arg1 = (Dali::Timer *)jarg1;
58426   if (!arg1) {
58427     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
58428     return 0;
58429   }
58430   {
58431     try {
58432       result = (Dali::Timer *)new Dali::Timer((Dali::Timer const &)*arg1);
58433     } catch (std::out_of_range& e) {
58434       {
58435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58436       };
58437     } catch (std::exception& e) {
58438       {
58439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58440       };
58441     } catch (Dali::DaliException e) {
58442       {
58443         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58444       };
58445     } catch (...) {
58446       {
58447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58448       };
58449     }
58450   }
58451
58452   jresult = (void *)result;
58453   return jresult;
58454 }
58455
58456
58457 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_Assign(void * jarg1, void * jarg2) {
58458   void * jresult ;
58459   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58460   Dali::Timer *arg2 = 0 ;
58461   Dali::Timer *result = 0 ;
58462
58463   arg1 = (Dali::Timer *)jarg1;
58464   arg2 = (Dali::Timer *)jarg2;
58465   if (!arg2) {
58466     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
58467     return 0;
58468   }
58469   {
58470     try {
58471       result = (Dali::Timer *) &(arg1)->operator =((Dali::Timer const &)*arg2);
58472     } catch (std::out_of_range& e) {
58473       {
58474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58475       };
58476     } catch (std::exception& e) {
58477       {
58478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58479       };
58480     } catch (Dali::DaliException e) {
58481       {
58482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58483       };
58484     } catch (...) {
58485       {
58486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58487       };
58488     }
58489   }
58490
58491   jresult = (void *)result;
58492   return jresult;
58493 }
58494
58495
58496 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Timer(void * jarg1) {
58497   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58498
58499   arg1 = (Dali::Timer *)jarg1;
58500   {
58501     try {
58502       delete arg1;
58503     } catch (std::out_of_range& e) {
58504       {
58505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58506       };
58507     } catch (std::exception& e) {
58508       {
58509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58510       };
58511     } catch (Dali::DaliException e) {
58512       {
58513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58514       };
58515     } catch (...) {
58516       {
58517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58518       };
58519     }
58520   }
58521
58522 }
58523
58524
58525 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_DownCast(void * jarg1) {
58526   void * jresult ;
58527   Dali::BaseHandle arg1 ;
58528   Dali::BaseHandle *argp1 ;
58529   Dali::Timer result;
58530
58531   argp1 = (Dali::BaseHandle *)jarg1;
58532   if (!argp1) {
58533     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
58534     return 0;
58535   }
58536   arg1 = *argp1;
58537   {
58538     try {
58539       result = Dali::Timer::DownCast(arg1);
58540     } catch (std::out_of_range& e) {
58541       {
58542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58543       };
58544     } catch (std::exception& e) {
58545       {
58546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58547       };
58548     } catch (Dali::DaliException e) {
58549       {
58550         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58551       };
58552     } catch (...) {
58553       {
58554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58555       };
58556     }
58557   }
58558
58559   jresult = new Dali::Timer((const Dali::Timer &)result);
58560   return jresult;
58561 }
58562
58563
58564 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Start(void * jarg1) {
58565   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58566
58567   arg1 = (Dali::Timer *)jarg1;
58568   {
58569     try {
58570       (arg1)->Start();
58571     } catch (std::out_of_range& e) {
58572       {
58573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58574       };
58575     } catch (std::exception& e) {
58576       {
58577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58578       };
58579     } catch (Dali::DaliException e) {
58580       {
58581         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58582       };
58583     } catch (...) {
58584       {
58585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58586       };
58587     }
58588   }
58589
58590 }
58591
58592
58593 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Stop(void * jarg1) {
58594   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58595
58596   arg1 = (Dali::Timer *)jarg1;
58597   {
58598     try {
58599       (arg1)->Stop();
58600     } catch (std::out_of_range& e) {
58601       {
58602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58603       };
58604     } catch (std::exception& e) {
58605       {
58606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58607       };
58608     } catch (Dali::DaliException e) {
58609       {
58610         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58611       };
58612     } catch (...) {
58613       {
58614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58615       };
58616     }
58617   }
58618
58619 }
58620
58621
58622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_SetInterval(void * jarg1, unsigned int jarg2) {
58623   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58624   unsigned int arg2 ;
58625
58626   arg1 = (Dali::Timer *)jarg1;
58627   arg2 = (unsigned int)jarg2;
58628   {
58629     try {
58630       (arg1)->SetInterval(arg2);
58631     } catch (std::out_of_range& e) {
58632       {
58633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58634       };
58635     } catch (std::exception& e) {
58636       {
58637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58638       };
58639     } catch (Dali::DaliException e) {
58640       {
58641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58642       };
58643     } catch (...) {
58644       {
58645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58646       };
58647     }
58648   }
58649
58650 }
58651
58652
58653 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_GetInterval(void * jarg1) {
58654   unsigned int jresult ;
58655   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58656   unsigned int result;
58657
58658   arg1 = (Dali::Timer *)jarg1;
58659   {
58660     try {
58661       result = (unsigned int)((Dali::Timer const *)arg1)->GetInterval();
58662     } catch (std::out_of_range& e) {
58663       {
58664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58665       };
58666     } catch (std::exception& e) {
58667       {
58668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58669       };
58670     } catch (Dali::DaliException e) {
58671       {
58672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58673       };
58674     } catch (...) {
58675       {
58676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58677       };
58678     }
58679   }
58680
58681   jresult = result;
58682   return jresult;
58683 }
58684
58685
58686 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_IsRunning(void * jarg1) {
58687   unsigned int jresult ;
58688   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58689   bool result;
58690
58691   arg1 = (Dali::Timer *)jarg1;
58692   {
58693     try {
58694       result = (bool)((Dali::Timer const *)arg1)->IsRunning();
58695     } catch (std::out_of_range& e) {
58696       {
58697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58698       };
58699     } catch (std::exception& e) {
58700       {
58701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58702       };
58703     } catch (Dali::DaliException e) {
58704       {
58705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58706       };
58707     } catch (...) {
58708       {
58709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58710       };
58711     }
58712   }
58713
58714   jresult = result;
58715   return jresult;
58716 }
58717
58718
58719 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_TickSignal(void * jarg1) {
58720   void * jresult ;
58721   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58722   Dali::Timer::TimerSignalType *result = 0 ;
58723
58724   arg1 = (Dali::Timer *)jarg1;
58725   {
58726     try {
58727       result = (Dali::Timer::TimerSignalType *) &(arg1)->TickSignal();
58728     } catch (std::out_of_range& e) {
58729       {
58730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58731       };
58732     } catch (std::exception& e) {
58733       {
58734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58735       };
58736     } catch (Dali::DaliException e) {
58737       {
58738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58739       };
58740     } catch (...) {
58741       {
58742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58743       };
58744     }
58745   }
58746
58747   jresult = (void *)result;
58748   return jresult;
58749 }
58750
58751
58752 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DragAndDropDetector() {
58753   void * jresult ;
58754   Dali::DragAndDropDetector *result = 0 ;
58755
58756   {
58757     try {
58758       result = (Dali::DragAndDropDetector *)new Dali::DragAndDropDetector();
58759     } catch (std::out_of_range& e) {
58760       {
58761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58762       };
58763     } catch (std::exception& e) {
58764       {
58765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58766       };
58767     } catch (Dali::DaliException e) {
58768       {
58769         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58770       };
58771     } catch (...) {
58772       {
58773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58774       };
58775     }
58776   }
58777
58778   jresult = (void *)result;
58779   return jresult;
58780 }
58781
58782
58783 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DragAndDropDetector(void * jarg1) {
58784   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58785
58786   arg1 = (Dali::DragAndDropDetector *)jarg1;
58787   {
58788     try {
58789       delete arg1;
58790     } catch (std::out_of_range& e) {
58791       {
58792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58793       };
58794     } catch (std::exception& e) {
58795       {
58796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58797       };
58798     } catch (Dali::DaliException e) {
58799       {
58800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58801       };
58802     } catch (...) {
58803       {
58804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58805       };
58806     }
58807   }
58808
58809 }
58810
58811
58812 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_GetContent(void * jarg1) {
58813   char * jresult ;
58814   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58815   std::string *result = 0 ;
58816
58817   arg1 = (Dali::DragAndDropDetector *)jarg1;
58818   {
58819     try {
58820       result = (std::string *) &((Dali::DragAndDropDetector const *)arg1)->GetContent();
58821     } catch (std::out_of_range& e) {
58822       {
58823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58824       };
58825     } catch (std::exception& e) {
58826       {
58827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58828       };
58829     } catch (Dali::DaliException e) {
58830       {
58831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58832       };
58833     } catch (...) {
58834       {
58835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58836       };
58837     }
58838   }
58839
58840   jresult = SWIG_csharp_string_callback(result->c_str());
58841   return jresult;
58842 }
58843
58844
58845 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_GetCurrentScreenPosition(void * jarg1) {
58846   void * jresult ;
58847   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58848   Dali::Vector2 result;
58849
58850   arg1 = (Dali::DragAndDropDetector *)jarg1;
58851   {
58852     try {
58853       result = ((Dali::DragAndDropDetector const *)arg1)->GetCurrentScreenPosition();
58854     } catch (std::out_of_range& e) {
58855       {
58856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58857       };
58858     } catch (std::exception& e) {
58859       {
58860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58861       };
58862     } catch (Dali::DaliException e) {
58863       {
58864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58865       };
58866     } catch (...) {
58867       {
58868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58869       };
58870     }
58871   }
58872
58873   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
58874   return jresult;
58875 }
58876
58877
58878 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_EnteredSignal(void * jarg1) {
58879   void * jresult ;
58880   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58881   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
58882
58883   arg1 = (Dali::DragAndDropDetector *)jarg1;
58884   {
58885     try {
58886       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->EnteredSignal();
58887     } catch (std::out_of_range& e) {
58888       {
58889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58890       };
58891     } catch (std::exception& e) {
58892       {
58893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58894       };
58895     } catch (Dali::DaliException e) {
58896       {
58897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58898       };
58899     } catch (...) {
58900       {
58901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58902       };
58903     }
58904   }
58905
58906   jresult = (void *)result;
58907   return jresult;
58908 }
58909
58910
58911 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_ExitedSignal(void * jarg1) {
58912   void * jresult ;
58913   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58914   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
58915
58916   arg1 = (Dali::DragAndDropDetector *)jarg1;
58917   {
58918     try {
58919       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->ExitedSignal();
58920     } catch (std::out_of_range& e) {
58921       {
58922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58923       };
58924     } catch (std::exception& e) {
58925       {
58926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58927       };
58928     } catch (Dali::DaliException e) {
58929       {
58930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58931       };
58932     } catch (...) {
58933       {
58934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58935       };
58936     }
58937   }
58938
58939   jresult = (void *)result;
58940   return jresult;
58941 }
58942
58943
58944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_MovedSignal(void * jarg1) {
58945   void * jresult ;
58946   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58947   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
58948
58949   arg1 = (Dali::DragAndDropDetector *)jarg1;
58950   {
58951     try {
58952       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->MovedSignal();
58953     } catch (std::out_of_range& e) {
58954       {
58955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58956       };
58957     } catch (std::exception& e) {
58958       {
58959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58960       };
58961     } catch (Dali::DaliException e) {
58962       {
58963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58964       };
58965     } catch (...) {
58966       {
58967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58968       };
58969     }
58970   }
58971
58972   jresult = (void *)result;
58973   return jresult;
58974 }
58975
58976
58977 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_DroppedSignal(void * jarg1) {
58978   void * jresult ;
58979   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58980   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
58981
58982   arg1 = (Dali::DragAndDropDetector *)jarg1;
58983   {
58984     try {
58985       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->DroppedSignal();
58986     } catch (std::out_of_range& e) {
58987       {
58988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58989       };
58990     } catch (std::exception& e) {
58991       {
58992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58993       };
58994     } catch (Dali::DaliException e) {
58995       {
58996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58997       };
58998     } catch (...) {
58999       {
59000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59001       };
59002     }
59003   }
59004
59005   jresult = (void *)result;
59006   return jresult;
59007 }
59008
59009
59010 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationExtensions__SWIG_0() {
59011   void * jresult ;
59012   Dali::ApplicationExtensions *result = 0 ;
59013
59014   {
59015     try {
59016       result = (Dali::ApplicationExtensions *)new Dali::ApplicationExtensions();
59017     } catch (std::out_of_range& e) {
59018       {
59019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59020       };
59021     } catch (std::exception& e) {
59022       {
59023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59024       };
59025     } catch (Dali::DaliException e) {
59026       {
59027         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59028       };
59029     } catch (...) {
59030       {
59031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59032       };
59033     }
59034   }
59035
59036   jresult = (void *)result;
59037   return jresult;
59038 }
59039
59040
59041 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationExtensions__SWIG_1(void * jarg1) {
59042   void * jresult ;
59043   Dali::Application *arg1 = (Dali::Application *) 0 ;
59044   Dali::ApplicationExtensions *result = 0 ;
59045
59046   arg1 = (Dali::Application *)jarg1;
59047   {
59048     try {
59049       result = (Dali::ApplicationExtensions *)new Dali::ApplicationExtensions(arg1);
59050     } catch (std::out_of_range& e) {
59051       {
59052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59053       };
59054     } catch (std::exception& e) {
59055       {
59056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59057       };
59058     } catch (Dali::DaliException e) {
59059       {
59060         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59061       };
59062     } catch (...) {
59063       {
59064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59065       };
59066     }
59067   }
59068
59069   jresult = (void *)result;
59070   return jresult;
59071 }
59072
59073
59074 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ApplicationExtensions(void * jarg1) {
59075   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
59076
59077   arg1 = (Dali::ApplicationExtensions *)jarg1;
59078   {
59079     try {
59080       delete arg1;
59081     } catch (std::out_of_range& e) {
59082       {
59083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59084       };
59085     } catch (std::exception& e) {
59086       {
59087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59088       };
59089     } catch (Dali::DaliException e) {
59090       {
59091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59092       };
59093     } catch (...) {
59094       {
59095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59096       };
59097     }
59098   }
59099
59100 }
59101
59102
59103 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Init(void * jarg1) {
59104   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
59105
59106   arg1 = (Dali::ApplicationExtensions *)jarg1;
59107   {
59108     try {
59109       (arg1)->Init();
59110     } catch (std::out_of_range& e) {
59111       {
59112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59113       };
59114     } catch (std::exception& e) {
59115       {
59116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59117       };
59118     } catch (Dali::DaliException e) {
59119       {
59120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59121       };
59122     } catch (...) {
59123       {
59124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59125       };
59126     }
59127   }
59128
59129 }
59130
59131 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Start(void * jarg1) {
59132   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
59133
59134   arg1 = (Dali::ApplicationExtensions *)jarg1;
59135   {
59136     try {
59137       (arg1)->Start();
59138     } catch (std::out_of_range& e) {
59139       {
59140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59141       };
59142     } catch (std::exception& e) {
59143       {
59144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59145       };
59146     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; }
59147   }
59148 }
59149
59150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Terminate(void * jarg1) {
59151   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
59152
59153   arg1 = (Dali::ApplicationExtensions *)jarg1;
59154   {
59155     try {
59156       (arg1)->Terminate();
59157     } catch (std::out_of_range& e) {
59158       {
59159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59160       };
59161     } catch (std::exception& e) {
59162       {
59163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59164       };
59165     } catch (Dali::DaliException e) {
59166       {
59167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59168       };
59169     } catch (...) {
59170       {
59171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59172       };
59173     }
59174   }
59175
59176 }
59177
59178
59179 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Pause(void * jarg1) {
59180   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
59181
59182   arg1 = (Dali::ApplicationExtensions *)jarg1;
59183   {
59184     try {
59185       (arg1)->Pause();
59186     } catch (std::out_of_range& e) {
59187       {
59188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59189       };
59190     } catch (std::exception& e) {
59191       {
59192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59193       };
59194     } catch (Dali::DaliException e) {
59195       {
59196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59197       };
59198     } catch (...) {
59199       {
59200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59201       };
59202     }
59203   }
59204
59205 }
59206
59207
59208 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Resume(void * jarg1) {
59209   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
59210
59211   arg1 = (Dali::ApplicationExtensions *)jarg1;
59212   {
59213     try {
59214       (arg1)->Resume();
59215     } catch (std::out_of_range& e) {
59216       {
59217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59218       };
59219     } catch (std::exception& e) {
59220       {
59221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59222       };
59223     } catch (Dali::DaliException e) {
59224       {
59225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59226       };
59227     } catch (...) {
59228       {
59229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59230       };
59231     }
59232   }
59233
59234 }
59235
59236
59237 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_LanguageChange(void * jarg1) {
59238   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
59239
59240   arg1 = (Dali::ApplicationExtensions *)jarg1;
59241   {
59242     try {
59243       (arg1)->LanguageChange();
59244     } catch (std::out_of_range& e) {
59245       {
59246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59247       };
59248     } catch (std::exception& e) {
59249       {
59250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59251       };
59252     } catch (Dali::DaliException e) {
59253       {
59254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59255       };
59256     } catch (...) {
59257       {
59258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59259       };
59260     }
59261   }
59262
59263 }
59264
59265
59266
59267 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Empty(void * jarg1) {
59268   unsigned int jresult ;
59269   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59270   bool result;
59271
59272   arg1 = (Dali::Signal< bool () > *)jarg1;
59273   {
59274     try {
59275       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Empty((Dali::Signal< bool () > const *)arg1);
59276     } catch (std::out_of_range& e) {
59277       {
59278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59279       };
59280     } catch (std::exception& e) {
59281       {
59282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59283       };
59284     } catch (Dali::DaliException e) {
59285       {
59286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59287       };
59288     } catch (...) {
59289       {
59290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59291       };
59292     }
59293   }
59294
59295   jresult = result;
59296   return jresult;
59297 }
59298
59299
59300 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TimerSignalType_GetConnectionCount(void * jarg1) {
59301   unsigned long jresult ;
59302   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59303   std::size_t result;
59304
59305   arg1 = (Dali::Signal< bool () > *)jarg1;
59306   {
59307     try {
59308       result = Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount((Dali::Signal< bool () > const *)arg1);
59309     } catch (std::out_of_range& e) {
59310       {
59311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59312       };
59313     } catch (std::exception& e) {
59314       {
59315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59316       };
59317     } catch (Dali::DaliException e) {
59318       {
59319         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59320       };
59321     } catch (...) {
59322       {
59323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59324       };
59325     }
59326   }
59327
59328   jresult = (unsigned long)result;
59329   return jresult;
59330 }
59331
59332
59333 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Connect(void * jarg1, void * jarg2) {
59334   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59335   bool (*arg2)() = (bool (*)()) 0 ;
59336
59337   arg1 = (Dali::Signal< bool () > *)jarg1;
59338   arg2 = (bool (*)())jarg2;
59339   {
59340     try {
59341       Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(arg1,arg2);
59342     } catch (std::out_of_range& e) {
59343       {
59344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59345       };
59346     } catch (std::exception& e) {
59347       {
59348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59349       };
59350     } catch (Dali::DaliException e) {
59351       {
59352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59353       };
59354     } catch (...) {
59355       {
59356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59357       };
59358     }
59359   }
59360
59361 }
59362
59363
59364 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Disconnect(void * jarg1, void * jarg2) {
59365   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59366   bool (*arg2)() = (bool (*)()) 0 ;
59367
59368   arg1 = (Dali::Signal< bool () > *)jarg1;
59369   arg2 = (bool (*)())jarg2;
59370   {
59371     try {
59372       Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(arg1,arg2);
59373     } catch (std::out_of_range& e) {
59374       {
59375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59376       };
59377     } catch (std::exception& e) {
59378       {
59379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59380       };
59381     } catch (Dali::DaliException e) {
59382       {
59383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59384       };
59385     } catch (...) {
59386       {
59387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59388       };
59389     }
59390   }
59391
59392 }
59393
59394
59395 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Emit(void * jarg1) {
59396   unsigned int jresult ;
59397   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59398   bool result;
59399
59400   arg1 = (Dali::Signal< bool () > *)jarg1;
59401   {
59402     try {
59403       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(arg1);
59404     } catch (std::out_of_range& e) {
59405       {
59406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59407       };
59408     } catch (std::exception& e) {
59409       {
59410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59411       };
59412     } catch (Dali::DaliException e) {
59413       {
59414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59415       };
59416     } catch (...) {
59417       {
59418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59419       };
59420     }
59421   }
59422
59423   jresult = result;
59424   return jresult;
59425 }
59426
59427
59428 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimerSignalType() {
59429   void * jresult ;
59430   Dali::Signal< bool () > *result = 0 ;
59431
59432   {
59433     try {
59434       result = (Dali::Signal< bool () > *)new Dali::Signal< bool () >();
59435     } catch (std::out_of_range& e) {
59436       {
59437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59438       };
59439     } catch (std::exception& e) {
59440       {
59441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59442       };
59443     } catch (Dali::DaliException e) {
59444       {
59445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59446       };
59447     } catch (...) {
59448       {
59449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59450       };
59451     }
59452   }
59453
59454   jresult = (void *)result;
59455   return jresult;
59456 }
59457
59458
59459 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimerSignalType(void * jarg1) {
59460   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59461
59462   arg1 = (Dali::Signal< bool () > *)jarg1;
59463   {
59464     try {
59465       delete arg1;
59466     } catch (std::out_of_range& e) {
59467       {
59468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59469       };
59470     } catch (std::exception& e) {
59471       {
59472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59473       };
59474     } catch (Dali::DaliException e) {
59475       {
59476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59477       };
59478     } catch (...) {
59479       {
59480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59481       };
59482     }
59483   }
59484
59485 }
59486
59487
59488 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_TYPE_get() {
59489   int jresult ;
59490   int result;
59491
59492   {
59493     try {
59494       result = (int)Dali::Toolkit::Visual::Property::TYPE;
59495     } catch (std::out_of_range& e) {
59496       {
59497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59498       };
59499     } catch (std::exception& e) {
59500       {
59501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59502       };
59503     } catch (Dali::DaliException e) {
59504       {
59505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59506       };
59507     } catch (...) {
59508       {
59509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59510       };
59511     }
59512   }
59513
59514   jresult = (int)result;
59515   return jresult;
59516 }
59517
59518
59519 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_SHADER_get() {
59520   int jresult ;
59521   int result;
59522
59523   {
59524     try {
59525       result = (int)Dali::Toolkit::Visual::Property::SHADER;
59526     } catch (std::out_of_range& e) {
59527       {
59528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59529       };
59530     } catch (std::exception& e) {
59531       {
59532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59533       };
59534     } catch (Dali::DaliException e) {
59535       {
59536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59537       };
59538     } catch (...) {
59539       {
59540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59541       };
59542     }
59543   }
59544
59545   jresult = (int)result;
59546   return jresult;
59547 }
59548
59549
59550 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_VERTEX_get() {
59551   int jresult ;
59552   int result;
59553
59554   {
59555     try {
59556       result = (int)Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER;
59557     } catch (std::out_of_range& e) {
59558       {
59559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59560       };
59561     } catch (std::exception& e) {
59562       {
59563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59564       };
59565     } catch (Dali::DaliException e) {
59566       {
59567         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59568       };
59569     } catch (...) {
59570       {
59571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59572       };
59573     }
59574   }
59575
59576   jresult = (int)result;
59577   return jresult;
59578 }
59579
59580
59581 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_FRAGMENT_get() {
59582   int jresult ;
59583   int result;
59584
59585   {
59586     try {
59587       result = (int)Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER;
59588     } catch (std::out_of_range& e) {
59589       {
59590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59591       };
59592     } catch (std::exception& e) {
59593       {
59594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59595       };
59596     } catch (Dali::DaliException e) {
59597       {
59598         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59599       };
59600     } catch (...) {
59601       {
59602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59603       };
59604     }
59605   }
59606
59607   jresult = (int)result;
59608   return jresult;
59609 }
59610
59611
59612 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_X_get() {
59613   int jresult ;
59614   int result;
59615
59616   {
59617     try {
59618       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_X;
59619     } catch (std::out_of_range& e) {
59620       {
59621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59622       };
59623     } catch (std::exception& e) {
59624       {
59625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59626       };
59627     } catch (Dali::DaliException e) {
59628       {
59629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59630       };
59631     } catch (...) {
59632       {
59633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59634       };
59635     }
59636   }
59637
59638   jresult = (int)result;
59639   return jresult;
59640 }
59641
59642
59643 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_Y_get() {
59644   int jresult ;
59645   int result;
59646
59647   {
59648     try {
59649       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_Y;
59650     } catch (std::out_of_range& e) {
59651       {
59652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59653       };
59654     } catch (std::exception& e) {
59655       {
59656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59657       };
59658     } catch (Dali::DaliException e) {
59659       {
59660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59661       };
59662     } catch (...) {
59663       {
59664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59665       };
59666     }
59667   }
59668
59669   jresult = (int)result;
59670   return jresult;
59671 }
59672
59673
59674 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_HINTS_get() {
59675   int jresult ;
59676   int result;
59677
59678   {
59679     try {
59680       result = (int)Dali::Toolkit::Visual::Shader::Property::HINTS;
59681     } catch (std::out_of_range& e) {
59682       {
59683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59684       };
59685     } catch (std::exception& e) {
59686       {
59687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59688       };
59689     } catch (Dali::DaliException e) {
59690       {
59691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59692       };
59693     } catch (...) {
59694       {
59695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59696       };
59697     }
59698   }
59699
59700   jresult = (int)result;
59701   return jresult;
59702 }
59703
59704
59705 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_COLOR_get() {
59706   int jresult ;
59707   int result;
59708
59709   {
59710     try {
59711       result = (int)Dali::Toolkit::BorderVisual::Property::COLOR;
59712     } catch (std::out_of_range& e) {
59713       {
59714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59715       };
59716     } catch (std::exception& e) {
59717       {
59718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59719       };
59720     } catch (Dali::DaliException e) {
59721       {
59722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59723       };
59724     } catch (...) {
59725       {
59726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59727       };
59728     }
59729   }
59730
59731   jresult = (int)result;
59732   return jresult;
59733 }
59734
59735
59736 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_SIZE_get() {
59737   int jresult ;
59738   int result;
59739
59740   {
59741     try {
59742       result = (int)Dali::Toolkit::BorderVisual::Property::SIZE;
59743     } catch (std::out_of_range& e) {
59744       {
59745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59746       };
59747     } catch (std::exception& e) {
59748       {
59749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59750       };
59751     } catch (Dali::DaliException e) {
59752       {
59753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59754       };
59755     } catch (...) {
59756       {
59757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59758       };
59759     }
59760   }
59761
59762   jresult = (int)result;
59763   return jresult;
59764 }
59765
59766
59767 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_ANTI_ALIASING_get() {
59768   int jresult ;
59769   int result;
59770
59771   {
59772     try {
59773       result = (int)Dali::Toolkit::BorderVisual::Property::ANTI_ALIASING;
59774     } catch (std::out_of_range& e) {
59775       {
59776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59777       };
59778     } catch (std::exception& e) {
59779       {
59780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59781       };
59782     } catch (Dali::DaliException e) {
59783       {
59784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59785       };
59786     } catch (...) {
59787       {
59788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59789       };
59790     }
59791   }
59792
59793   jresult = (int)result;
59794   return jresult;
59795 }
59796
59797
59798 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_COLOR_VISUAL_MIX_COLOR_get() {
59799   int jresult ;
59800   int result;
59801
59802   {
59803     try {
59804       result = (int)Dali::Toolkit::ColorVisual::Property::MIX_COLOR;
59805     } catch (std::out_of_range& e) {
59806       {
59807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59808       };
59809     } catch (std::exception& e) {
59810       {
59811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59812       };
59813     } catch (Dali::DaliException e) {
59814       {
59815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59816       };
59817     } catch (...) {
59818       {
59819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59820       };
59821     }
59822   }
59823
59824   jresult = (int)result;
59825   return jresult;
59826 }
59827
59828
59829 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_START_POSITION_get() {
59830   int jresult ;
59831   int result;
59832
59833   {
59834     try {
59835       result = (int)Dali::Toolkit::GradientVisual::Property::START_POSITION;
59836     } catch (std::out_of_range& e) {
59837       {
59838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59839       };
59840     } catch (std::exception& e) {
59841       {
59842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59843       };
59844     } catch (Dali::DaliException e) {
59845       {
59846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59847       };
59848     } catch (...) {
59849       {
59850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59851       };
59852     }
59853   }
59854
59855   jresult = (int)result;
59856   return jresult;
59857 }
59858
59859
59860 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_END_POSITION_get() {
59861   int jresult ;
59862   int result;
59863
59864   {
59865     try {
59866       result = (int)Dali::Toolkit::GradientVisual::Property::END_POSITION;
59867     } catch (std::out_of_range& e) {
59868       {
59869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59870       };
59871     } catch (std::exception& e) {
59872       {
59873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59874       };
59875     } catch (Dali::DaliException e) {
59876       {
59877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59878       };
59879     } catch (...) {
59880       {
59881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59882       };
59883     }
59884   }
59885
59886   jresult = (int)result;
59887   return jresult;
59888 }
59889
59890
59891 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_CENTER_get() {
59892   int jresult ;
59893   int result;
59894
59895   {
59896     try {
59897       result = (int)Dali::Toolkit::GradientVisual::Property::CENTER;
59898     } catch (std::out_of_range& e) {
59899       {
59900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59901       };
59902     } catch (std::exception& e) {
59903       {
59904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59905       };
59906     } catch (Dali::DaliException e) {
59907       {
59908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59909       };
59910     } catch (...) {
59911       {
59912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59913       };
59914     }
59915   }
59916
59917   jresult = (int)result;
59918   return jresult;
59919 }
59920
59921
59922 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_RADIUS_get() {
59923   int jresult ;
59924   int result;
59925
59926   {
59927     try {
59928       result = (int)Dali::Toolkit::GradientVisual::Property::RADIUS;
59929     } catch (std::out_of_range& e) {
59930       {
59931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59932       };
59933     } catch (std::exception& e) {
59934       {
59935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59936       };
59937     } catch (Dali::DaliException e) {
59938       {
59939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59940       };
59941     } catch (...) {
59942       {
59943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59944       };
59945     }
59946   }
59947
59948   jresult = (int)result;
59949   return jresult;
59950 }
59951
59952
59953 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_OFFSET_get() {
59954   int jresult ;
59955   int result;
59956
59957   {
59958     try {
59959       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_OFFSET;
59960     } catch (std::out_of_range& e) {
59961       {
59962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59963       };
59964     } catch (std::exception& e) {
59965       {
59966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59967       };
59968     } catch (Dali::DaliException e) {
59969       {
59970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59971       };
59972     } catch (...) {
59973       {
59974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59975       };
59976     }
59977   }
59978
59979   jresult = (int)result;
59980   return jresult;
59981 }
59982
59983
59984 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_COLOR_get() {
59985   int jresult ;
59986   int result;
59987
59988   {
59989     try {
59990       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_COLOR;
59991     } catch (std::out_of_range& e) {
59992       {
59993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59994       };
59995     } catch (std::exception& e) {
59996       {
59997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59998       };
59999     } catch (Dali::DaliException e) {
60000       {
60001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60002       };
60003     } catch (...) {
60004       {
60005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60006       };
60007     }
60008   }
60009
60010   jresult = (int)result;
60011   return jresult;
60012 }
60013
60014
60015 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_UNITS_get() {
60016   int jresult ;
60017   int result;
60018
60019   {
60020     try {
60021       result = (int)Dali::Toolkit::GradientVisual::Property::UNITS;
60022     } catch (std::out_of_range& e) {
60023       {
60024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60025       };
60026     } catch (std::exception& e) {
60027       {
60028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60029       };
60030     } catch (Dali::DaliException e) {
60031       {
60032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60033       };
60034     } catch (...) {
60035       {
60036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60037       };
60038     }
60039   }
60040
60041   jresult = (int)result;
60042   return jresult;
60043 }
60044
60045
60046 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_SPREAD_METHOD_get() {
60047   int jresult ;
60048   int result;
60049
60050   {
60051     try {
60052       result = (int)Dali::Toolkit::GradientVisual::Property::SPREAD_METHOD;
60053     } catch (std::out_of_range& e) {
60054       {
60055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60056       };
60057     } catch (std::exception& e) {
60058       {
60059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60060       };
60061     } catch (Dali::DaliException e) {
60062       {
60063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60064       };
60065     } catch (...) {
60066       {
60067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60068       };
60069     }
60070   }
60071
60072   jresult = (int)result;
60073   return jresult;
60074 }
60075
60076
60077 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_URL_get() {
60078   int jresult ;
60079   int result;
60080
60081   {
60082     try {
60083       result = (int)Dali::Toolkit::ImageVisual::Property::URL;
60084     } catch (std::out_of_range& e) {
60085       {
60086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60087       };
60088     } catch (std::exception& e) {
60089       {
60090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60091       };
60092     } catch (Dali::DaliException e) {
60093       {
60094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60095       };
60096     } catch (...) {
60097       {
60098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60099       };
60100     }
60101   }
60102
60103   jresult = (int)result;
60104   return jresult;
60105 }
60106
60107 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ALPHA_MASK_URL_get() {
60108   int jresult ;
60109   int result;
60110
60111   {
60112     try {
60113       result = (int)Dali::Toolkit::ImageVisual::Property::ALPHA_MASK_URL;
60114     } catch (std::out_of_range& e) {
60115       {
60116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60117       };
60118     } catch (std::exception& e) {
60119       {
60120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60121       };
60122     } catch (Dali::DaliException e) {
60123       {
60124         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60125       };
60126     } catch (...) {
60127       {
60128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60129       };
60130     }
60131   }
60132
60133   jresult = (int)result;
60134   return jresult;
60135 }
60136
60137
60138 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BATCH_SIZE_get() {
60139   int jresult ;
60140   int result;
60141   {
60142     try
60143     {
60144       result = (int)Dali::Toolkit::ImageVisual::Property::BATCH_SIZE;
60145     } catch (std::out_of_range& e) {
60146       {
60147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60148       };
60149     } catch (std::exception& e) {
60150       {
60151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60152       };
60153     } catch (Dali::DaliException e) {
60154       {
60155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60156       };
60157     } catch (...) {
60158       {
60159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60160       };
60161     }
60162   }
60163
60164   jresult = (int)result;
60165   return jresult;
60166 }
60167
60168 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CACHE_SIZE_get() {
60169   int jresult ;
60170   int result;
60171   {
60172     try
60173     {
60174       result = (int)Dali::Toolkit::ImageVisual::Property::CACHE_SIZE;
60175     } catch (std::out_of_range& e) {
60176       {
60177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60178       };
60179     } catch (std::exception& e) {
60180       {
60181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60182       };
60183     } catch (Dali::DaliException e) {
60184       {
60185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60186       };
60187     } catch (...) {
60188       {
60189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60190       };
60191     }
60192   }
60193
60194   jresult = (int)result;
60195   return jresult;
60196 }
60197
60198 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FRAME_DELAY_get() {
60199   int jresult ;
60200   int result;
60201   {
60202     try
60203     {
60204       result = (int)Dali::Toolkit::ImageVisual::Property::FRAME_DELAY;
60205     } catch (std::out_of_range& e) {
60206       {
60207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60208       };
60209     } catch (std::exception& e) {
60210       {
60211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60212       };
60213     } catch (Dali::DaliException e) {
60214       {
60215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60216       };
60217     } catch (...) {
60218       {
60219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60220       };
60221     }
60222   }
60223
60224   jresult = (int)result;
60225   return jresult;
60226 }
60227
60228 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOOP_COUNT_get() {
60229   return (int)Dali::Toolkit::DevelImageVisual::Property::LOOP_COUNT;
60230 }
60231
60232 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_MASK_CONTENT_SCALE_get() {
60233   int jresult ;
60234   int result;
60235   {
60236     try
60237     {
60238       result = (int)Dali::Toolkit::ImageVisual::Property::MASK_CONTENT_SCALE;
60239     } catch (std::out_of_range& e) {
60240       {
60241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60242       };
60243     } catch (std::exception& e) {
60244       {
60245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60246       };
60247     } catch (Dali::DaliException e) {
60248       {
60249         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60250       };
60251     } catch (...) {
60252       {
60253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60254       };
60255     }
60256   }
60257
60258   jresult = (int)result;
60259   return jresult;
60260 }
60261
60262 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CROP_TO_MASK_get() {
60263   int jresult ;
60264   int result;
60265   {
60266     try
60267     {
60268       result = (int)Dali::Toolkit::ImageVisual::Property::CROP_TO_MASK;
60269     } catch (std::out_of_range& e) {
60270       {
60271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60272       };
60273     } catch (std::exception& e) {
60274       {
60275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60276       };
60277     } catch (Dali::DaliException e) {
60278       {
60279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60280       };
60281     } catch (...) {
60282       {
60283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60284       };
60285     }
60286   }
60287
60288   jresult = (int)result;
60289   return jresult;
60290 }
60291
60292 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FITTING_MODE_get() {
60293   int jresult ;
60294   int result;
60295
60296   {
60297     try {
60298       result = (int)Dali::Toolkit::ImageVisual::Property::FITTING_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_IMAGE_VISUAL_SAMPLING_MODE_get() {
60324   int jresult ;
60325   int result;
60326
60327   {
60328     try {
60329       result = (int)Dali::Toolkit::ImageVisual::Property::SAMPLING_MODE;
60330     } catch (std::out_of_range& e) {
60331       {
60332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60333       };
60334     } catch (std::exception& e) {
60335       {
60336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60337       };
60338     } catch (Dali::DaliException e) {
60339       {
60340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60341       };
60342     } catch (...) {
60343       {
60344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60345       };
60346     }
60347   }
60348
60349   jresult = (int)result;
60350   return jresult;
60351 }
60352
60353 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_RELEASE_POLICY_get() {
60354   int jresult ;
60355   int result;
60356   {
60357     try
60358     {
60359       result = (int)Dali::Toolkit::ImageVisual::Property::RELEASE_POLICY;
60360     } catch (std::out_of_range& e) {
60361       {
60362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60363       };
60364     } catch (std::exception& e) {
60365       {
60366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60367       };
60368     } catch (...) {
60369       {
60370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60371       };
60372     }
60373   }
60374   jresult = (int)result;
60375   return jresult;
60376 }
60377
60378 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOAD_POLICY_get() {
60379   int jresult ;
60380   int result;
60381   {
60382     try
60383     {
60384       result = (int)Dali::Toolkit::ImageVisual::Property::LOAD_POLICY;
60385     } catch (std::out_of_range& e) {
60386       {
60387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60388       };
60389     } catch (std::exception& e) {
60390       {
60391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60392       };
60393     } catch (...) {
60394       {
60395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60396       };
60397     }
60398   }
60399   jresult = (int)result;
60400   return jresult;
60401 }
60402
60403 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ORIENTATION_CORRECTION_get() {
60404   int jresult ;
60405   int result;
60406   {
60407     try
60408     {
60409       result = (int)Dali::Toolkit::ImageVisual::Property::ORIENTATION_CORRECTION;
60410     } catch (std::out_of_range& e) {
60411       {
60412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60413       };
60414     } catch (std::exception& e) {
60415       {
60416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60417       };
60418     } catch (...) {
60419       {
60420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60421       };
60422     }
60423   }
60424   jresult = (int)result;
60425   return jresult;
60426 }
60427
60428
60429 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_URL_get() {
60430   int jresult ;
60431   int result;
60432   {
60433     try
60434     {
60435       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE;
60436     } catch (std::out_of_range& e) {
60437       {
60438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60439       };
60440     } catch (std::exception& e) {
60441       {
60442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60443       };
60444     } catch (...) {
60445       {
60446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60447       };
60448     }
60449   }
60450   jresult = (int)result;
60451   return jresult;
60452 }
60453
60454 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_ALPHA_get() {
60455   int jresult ;
60456   int result;
60457   {
60458     try
60459     {
60460       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE_ALPHA;
60461     } catch (std::out_of_range& e) {
60462       {
60463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60464       };
60465     } catch (std::exception& e) {
60466       {
60467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60468       };
60469     } catch (...) {
60470       {
60471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60472       };
60473     }
60474   }
60475   jresult = (int)result;
60476   return jresult;
60477 }
60478
60479
60480
60481 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_WIDTH_get() {
60482   int jresult ;
60483   int result;
60484
60485   {
60486     try {
60487       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_WIDTH;
60488     } catch (std::out_of_range& e) {
60489       {
60490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60491       };
60492     } catch (std::exception& e) {
60493       {
60494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60495       };
60496     } catch (Dali::DaliException e) {
60497       {
60498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60499       };
60500     } catch (...) {
60501       {
60502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60503       };
60504     }
60505   }
60506
60507   jresult = (int)result;
60508   return jresult;
60509 }
60510
60511
60512 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_HEIGHT_get() {
60513   int jresult ;
60514   int result;
60515
60516   {
60517     try {
60518       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_HEIGHT;
60519     } catch (std::out_of_range& e) {
60520       {
60521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60522       };
60523     } catch (std::exception& e) {
60524       {
60525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60526       };
60527     } catch (Dali::DaliException e) {
60528       {
60529         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60530       };
60531     } catch (...) {
60532       {
60533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60534       };
60535     }
60536   }
60537
60538   jresult = (int)result;
60539   return jresult;
60540 }
60541
60542
60543 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SYNCHRONOUS_LOADING_get() {
60544   int jresult ;
60545   int result;
60546
60547   {
60548     try {
60549       result = (int)Dali::Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING;
60550     } catch (std::out_of_range& e) {
60551       {
60552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60553       };
60554     } catch (std::exception& e) {
60555       {
60556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60557       };
60558     } catch (Dali::DaliException e) {
60559       {
60560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60561       };
60562     } catch (...) {
60563       {
60564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60565       };
60566     }
60567   }
60568
60569   jresult = (int)result;
60570   return jresult;
60571 }
60572
60573
60574 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BORDER_ONLY_get() {
60575   int jresult ;
60576   int result;
60577
60578   {
60579     try {
60580       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER_ONLY;
60581     } catch (std::out_of_range& e) {
60582       {
60583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60584       };
60585     } catch (std::exception& e) {
60586       {
60587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60588       };
60589     } catch (Dali::DaliException e) {
60590       {
60591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60592       };
60593     } catch (...) {
60594       {
60595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60596       };
60597     }
60598   }
60599
60600   jresult = (int)result;
60601   return jresult;
60602 }
60603
60604
60605 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_PIXEL_AREA_get() {
60606   int jresult ;
60607   int result;
60608
60609   {
60610     try {
60611       result = (int)Dali::Toolkit::ImageVisual::Property::PIXEL_AREA;
60612     } catch (std::out_of_range& e) {
60613       {
60614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60615       };
60616     } catch (std::exception& e) {
60617       {
60618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60619       };
60620     } catch (Dali::DaliException e) {
60621       {
60622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60623       };
60624     } catch (...) {
60625       {
60626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60627       };
60628     }
60629   }
60630
60631   jresult = (int)result;
60632   return jresult;
60633 }
60634
60635
60636 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_U_get() {
60637   int jresult ;
60638   int result;
60639
60640   {
60641     try {
60642       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_U;
60643     } catch (std::out_of_range& e) {
60644       {
60645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60646       };
60647     } catch (std::exception& e) {
60648       {
60649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60650       };
60651     } catch (Dali::DaliException e) {
60652       {
60653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60654       };
60655     } catch (...) {
60656       {
60657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60658       };
60659     }
60660   }
60661
60662   jresult = (int)result;
60663   return jresult;
60664 }
60665
60666
60667 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_V_get() {
60668   int jresult ;
60669   int result;
60670
60671   {
60672     try {
60673       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_V;
60674     } catch (std::out_of_range& e) {
60675       {
60676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60677       };
60678     } catch (std::exception& e) {
60679       {
60680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60681       };
60682     } catch (Dali::DaliException e) {
60683       {
60684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60685       };
60686     } catch (...) {
60687       {
60688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60689       };
60690     }
60691   }
60692
60693   jresult = (int)result;
60694   return jresult;
60695 }
60696
60697 SWIGEXPORT int SWIGSTDCALL CSharp_Image_Visual_BORDER_get() {
60698   int jresult ;
60699   int result;
60700
60701   {
60702     try {
60703       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER;
60704     } catch (std::out_of_range& e) {
60705       {
60706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60707       };
60708     } catch (std::exception& e) {
60709       {
60710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60711       };
60712     } catch (...) {
60713       {
60714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60715       };
60716     }
60717   }
60718   jresult = (int)result;
60719   return jresult;
60720 }
60721
60722 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_OBJECT_URL_get() {
60723   int jresult ;
60724   int result;
60725
60726   {
60727     try {
60728       result = (int)Dali::Toolkit::MeshVisual::Property::OBJECT_URL;
60729     } catch (std::out_of_range& e) {
60730       {
60731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60732       };
60733     } catch (std::exception& e) {
60734       {
60735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60736       };
60737     } catch (Dali::DaliException e) {
60738       {
60739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60740       };
60741     } catch (...) {
60742       {
60743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60744       };
60745     }
60746   }
60747
60748   jresult = (int)result;
60749   return jresult;
60750 }
60751
60752
60753 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_MATERIAL_URL_get() {
60754   int jresult ;
60755   int result;
60756
60757   {
60758     try {
60759       result = (int)Dali::Toolkit::MeshVisual::Property::MATERIAL_URL;
60760     } catch (std::out_of_range& e) {
60761       {
60762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60763       };
60764     } catch (std::exception& e) {
60765       {
60766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60767       };
60768     } catch (Dali::DaliException e) {
60769       {
60770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60771       };
60772     } catch (...) {
60773       {
60774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60775       };
60776     }
60777   }
60778
60779   jresult = (int)result;
60780   return jresult;
60781 }
60782
60783
60784 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_TEXTURES_PATH_get() {
60785   int jresult ;
60786   int result;
60787
60788   {
60789     try {
60790       result = (int)Dali::Toolkit::MeshVisual::Property::TEXTURES_PATH;
60791     } catch (std::out_of_range& e) {
60792       {
60793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60794       };
60795     } catch (std::exception& e) {
60796       {
60797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60798       };
60799     } catch (Dali::DaliException e) {
60800       {
60801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60802       };
60803     } catch (...) {
60804       {
60805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60806       };
60807     }
60808   }
60809
60810   jresult = (int)result;
60811   return jresult;
60812 }
60813
60814
60815 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_SHADING_MODE_get() {
60816   int jresult ;
60817   int result;
60818
60819   {
60820     try {
60821       result = (int)Dali::Toolkit::MeshVisual::Property::SHADING_MODE;
60822     } catch (std::out_of_range& e) {
60823       {
60824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60825       };
60826     } catch (std::exception& e) {
60827       {
60828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60829       };
60830     } catch (Dali::DaliException e) {
60831       {
60832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60833       };
60834     } catch (...) {
60835       {
60836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60837       };
60838     }
60839   }
60840
60841   jresult = (int)result;
60842   return jresult;
60843 }
60844
60845
60846 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_MIPMAPPING_get() {
60847   int jresult ;
60848   int result;
60849
60850   {
60851     try {
60852       result = (int)Dali::Toolkit::MeshVisual::Property::USE_MIPMAPPING;
60853     } catch (std::out_of_range& e) {
60854       {
60855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60856       };
60857     } catch (std::exception& e) {
60858       {
60859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60860       };
60861     } catch (Dali::DaliException e) {
60862       {
60863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60864       };
60865     } catch (...) {
60866       {
60867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60868       };
60869     }
60870   }
60871
60872   jresult = (int)result;
60873   return jresult;
60874 }
60875
60876
60877 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_SOFT_NORMALS_get() {
60878   int jresult ;
60879   int result;
60880
60881   {
60882     try {
60883       result = (int)Dali::Toolkit::MeshVisual::Property::USE_SOFT_NORMALS;
60884     } catch (std::out_of_range& e) {
60885       {
60886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60887       };
60888     } catch (std::exception& e) {
60889       {
60890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60891       };
60892     } catch (Dali::DaliException e) {
60893       {
60894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60895       };
60896     } catch (...) {
60897       {
60898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60899       };
60900     }
60901   }
60902
60903   jresult = (int)result;
60904   return jresult;
60905 }
60906
60907
60908 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_LIGHT_POSITION_get() {
60909   int jresult ;
60910   int result;
60911
60912   {
60913     try {
60914       result = (int)Dali::Toolkit::MeshVisual::Property::LIGHT_POSITION;
60915     } catch (std::out_of_range& e) {
60916       {
60917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60918       };
60919     } catch (std::exception& e) {
60920       {
60921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60922       };
60923     } catch (Dali::DaliException e) {
60924       {
60925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60926       };
60927     } catch (...) {
60928       {
60929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60930       };
60931     }
60932   }
60933
60934   jresult = (int)result;
60935   return jresult;
60936 }
60937
60938
60939 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SHAPE_get() {
60940   int jresult ;
60941   int result;
60942
60943   {
60944     try {
60945       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SHAPE;
60946     } catch (std::out_of_range& e) {
60947       {
60948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60949       };
60950     } catch (std::exception& e) {
60951       {
60952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60953       };
60954     } catch (Dali::DaliException e) {
60955       {
60956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60957       };
60958     } catch (...) {
60959       {
60960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60961       };
60962     }
60963   }
60964
60965   jresult = (int)result;
60966   return jresult;
60967 }
60968
60969
60970 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_MIX_COLOR_get() {
60971   int jresult ;
60972   int result;
60973
60974   {
60975     try {
60976       result = (int)Dali::Toolkit::PrimitiveVisual::Property::MIX_COLOR;
60977     } catch (std::out_of_range& e) {
60978       {
60979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60980       };
60981     } catch (std::exception& e) {
60982       {
60983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60984       };
60985     } catch (Dali::DaliException e) {
60986       {
60987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60988       };
60989     } catch (...) {
60990       {
60991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60992       };
60993     }
60994   }
60995
60996   jresult = (int)result;
60997   return jresult;
60998 }
60999
61000
61001 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SLICES_get() {
61002   int jresult ;
61003   int result;
61004
61005   {
61006     try {
61007       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SLICES;
61008     } catch (std::out_of_range& e) {
61009       {
61010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61011       };
61012     } catch (std::exception& e) {
61013       {
61014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61015       };
61016     } catch (Dali::DaliException e) {
61017       {
61018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61019       };
61020     } catch (...) {
61021       {
61022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61023       };
61024     }
61025   }
61026
61027   jresult = (int)result;
61028   return jresult;
61029 }
61030
61031
61032 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_STACKS_get() {
61033   int jresult ;
61034   int result;
61035
61036   {
61037     try {
61038       result = (int)Dali::Toolkit::PrimitiveVisual::Property::STACKS;
61039     } catch (std::out_of_range& e) {
61040       {
61041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61042       };
61043     } catch (std::exception& e) {
61044       {
61045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61046       };
61047     } catch (Dali::DaliException e) {
61048       {
61049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61050       };
61051     } catch (...) {
61052       {
61053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61054       };
61055     }
61056   }
61057
61058   jresult = (int)result;
61059   return jresult;
61060 }
61061
61062
61063 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_TOP_RADIUS_get() {
61064   int jresult ;
61065   int result;
61066
61067   {
61068     try {
61069       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_TOP_RADIUS;
61070     } catch (std::out_of_range& e) {
61071       {
61072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61073       };
61074     } catch (std::exception& e) {
61075       {
61076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61077       };
61078     } catch (Dali::DaliException e) {
61079       {
61080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61081       };
61082     } catch (...) {
61083       {
61084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61085       };
61086     }
61087   }
61088
61089   jresult = (int)result;
61090   return jresult;
61091 }
61092
61093
61094 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_BOTTOM_RADIUS_get() {
61095   int jresult ;
61096   int result;
61097
61098   {
61099     try {
61100       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS;
61101     } catch (std::out_of_range& e) {
61102       {
61103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61104       };
61105     } catch (std::exception& e) {
61106       {
61107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61108       };
61109     } catch (Dali::DaliException e) {
61110       {
61111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61112       };
61113     } catch (...) {
61114       {
61115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61116       };
61117     }
61118   }
61119
61120   jresult = (int)result;
61121   return jresult;
61122 }
61123
61124
61125 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_HEIGHT_get() {
61126   int jresult ;
61127   int result;
61128
61129   {
61130     try {
61131       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_HEIGHT;
61132     } catch (std::out_of_range& e) {
61133       {
61134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61135       };
61136     } catch (std::exception& e) {
61137       {
61138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61139       };
61140     } catch (Dali::DaliException e) {
61141       {
61142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61143       };
61144     } catch (...) {
61145       {
61146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61147       };
61148     }
61149   }
61150
61151   jresult = (int)result;
61152   return jresult;
61153 }
61154
61155
61156 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_RADIUS_get() {
61157   int jresult ;
61158   int result;
61159
61160   {
61161     try {
61162       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_RADIUS;
61163     } catch (std::out_of_range& e) {
61164       {
61165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61166       };
61167     } catch (std::exception& e) {
61168       {
61169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61170       };
61171     } catch (Dali::DaliException e) {
61172       {
61173         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61174       };
61175     } catch (...) {
61176       {
61177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61178       };
61179     }
61180   }
61181
61182   jresult = (int)result;
61183   return jresult;
61184 }
61185
61186
61187 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_DIMENSIONS_get() {
61188   int jresult ;
61189   int result;
61190
61191   {
61192     try {
61193       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_DIMENSIONS;
61194     } catch (std::out_of_range& e) {
61195       {
61196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61197       };
61198     } catch (std::exception& e) {
61199       {
61200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61201       };
61202     } catch (Dali::DaliException e) {
61203       {
61204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61205       };
61206     } catch (...) {
61207       {
61208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61209       };
61210     }
61211   }
61212
61213   jresult = (int)result;
61214   return jresult;
61215 }
61216
61217
61218 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_PERCENTAGE_get() {
61219   int jresult ;
61220   int result;
61221
61222   {
61223     try {
61224       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_PERCENTAGE;
61225     } catch (std::out_of_range& e) {
61226       {
61227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61228       };
61229     } catch (std::exception& e) {
61230       {
61231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61232       };
61233     } catch (Dali::DaliException e) {
61234       {
61235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61236       };
61237     } catch (...) {
61238       {
61239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61240       };
61241     }
61242   }
61243
61244   jresult = (int)result;
61245   return jresult;
61246 }
61247
61248
61249 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_SMOOTHNESS_get() {
61250   int jresult ;
61251   int result;
61252
61253   {
61254     try {
61255       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_SMOOTHNESS;
61256     } catch (std::out_of_range& e) {
61257       {
61258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61259       };
61260     } catch (std::exception& e) {
61261       {
61262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61263       };
61264     } catch (Dali::DaliException e) {
61265       {
61266         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61267       };
61268     } catch (...) {
61269       {
61270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61271       };
61272     }
61273   }
61274
61275   jresult = (int)result;
61276   return jresult;
61277 }
61278
61279
61280 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_LIGHT_POSITION_get() {
61281   int jresult ;
61282   int result;
61283
61284   {
61285     try {
61286       result = (int)Dali::Toolkit::PrimitiveVisual::Property::LIGHT_POSITION;
61287     } catch (std::out_of_range& e) {
61288       {
61289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61290       };
61291     } catch (std::exception& e) {
61292       {
61293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61294       };
61295     } catch (Dali::DaliException e) {
61296       {
61297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61298       };
61299     } catch (...) {
61300       {
61301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61302       };
61303     }
61304   }
61305
61306   jresult = (int)result;
61307   return jresult;
61308 }
61309
61310
61311 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_get() {
61312   int jresult ;
61313   int result;
61314
61315   {
61316     try {
61317       result = (int)Dali::Toolkit::TextVisual::Property::TEXT;
61318     } catch (std::out_of_range& e) {
61319       {
61320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61321       };
61322     } catch (std::exception& e) {
61323       {
61324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61325       };
61326     } catch (Dali::DaliException e) {
61327       {
61328         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61329       };
61330     } catch (...) {
61331       {
61332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61333       };
61334     }
61335   }
61336
61337   jresult = (int)result;
61338   return jresult;
61339 }
61340
61341
61342 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_FAMILY_get() {
61343   int jresult ;
61344   int result;
61345
61346   {
61347     try {
61348       result = (int)Dali::Toolkit::TextVisual::Property::FONT_FAMILY;
61349     } catch (std::out_of_range& e) {
61350       {
61351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61352       };
61353     } catch (std::exception& e) {
61354       {
61355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61356       };
61357     } catch (Dali::DaliException e) {
61358       {
61359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61360       };
61361     } catch (...) {
61362       {
61363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61364       };
61365     }
61366   }
61367
61368   jresult = (int)result;
61369   return jresult;
61370 }
61371
61372
61373 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_STYLE_get() {
61374   int jresult ;
61375   int result;
61376
61377   {
61378     try {
61379       result = (int)Dali::Toolkit::TextVisual::Property::FONT_STYLE;
61380     } catch (std::out_of_range& e) {
61381       {
61382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61383       };
61384     } catch (std::exception& e) {
61385       {
61386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61387       };
61388     } catch (Dali::DaliException e) {
61389       {
61390         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61391       };
61392     } catch (...) {
61393       {
61394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61395       };
61396     }
61397   }
61398
61399   jresult = (int)result;
61400   return jresult;
61401 }
61402
61403
61404 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_POINT_SIZE_get() {
61405   int jresult ;
61406   int result;
61407
61408   {
61409     try {
61410       result = (int)Dali::Toolkit::TextVisual::Property::POINT_SIZE;
61411     } catch (std::out_of_range& e) {
61412       {
61413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61414       };
61415     } catch (std::exception& e) {
61416       {
61417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61418       };
61419     } catch (Dali::DaliException e) {
61420       {
61421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61422       };
61423     } catch (...) {
61424       {
61425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61426       };
61427     }
61428   }
61429
61430   jresult = (int)result;
61431   return jresult;
61432 }
61433
61434
61435 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_MULTI_LINE_get() {
61436   int jresult ;
61437   int result;
61438
61439   {
61440     try {
61441       result = (int)Dali::Toolkit::TextVisual::Property::MULTI_LINE;
61442     } catch (std::out_of_range& e) {
61443       {
61444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61445       };
61446     } catch (std::exception& e) {
61447       {
61448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61449       };
61450     } catch (Dali::DaliException e) {
61451       {
61452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61453       };
61454     } catch (...) {
61455       {
61456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61457       };
61458     }
61459   }
61460
61461   jresult = (int)result;
61462   return jresult;
61463 }
61464
61465
61466 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_HORIZONTAL_ALIGNMENT_get() {
61467   int jresult ;
61468   int result;
61469
61470   {
61471     try {
61472       result = (int)Dali::Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT;
61473     } catch (std::out_of_range& e) {
61474       {
61475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61476       };
61477     } catch (std::exception& e) {
61478       {
61479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61480       };
61481     } catch (Dali::DaliException e) {
61482       {
61483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61484       };
61485     } catch (...) {
61486       {
61487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61488       };
61489     }
61490   }
61491
61492   jresult = (int)result;
61493   return jresult;
61494 }
61495
61496
61497 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_VERTICAL_ALIGNMENT_get() {
61498   int jresult ;
61499   int result;
61500
61501   {
61502     try {
61503       result = (int)Dali::Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT;
61504     } catch (std::out_of_range& e) {
61505       {
61506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61507       };
61508     } catch (std::exception& e) {
61509       {
61510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61511       };
61512     } catch (Dali::DaliException e) {
61513       {
61514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61515       };
61516     } catch (...) {
61517       {
61518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61519       };
61520     }
61521   }
61522
61523   jresult = (int)result;
61524   return jresult;
61525 }
61526
61527
61528 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_COLOR_get() {
61529   int jresult ;
61530   int result;
61531
61532   {
61533     try {
61534       result = (int)Dali::Toolkit::TextVisual::Property::TEXT_COLOR;
61535     } catch (std::out_of_range& e) {
61536       {
61537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61538       };
61539     } catch (std::exception& e) {
61540       {
61541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61542       };
61543     } catch (Dali::DaliException e) {
61544       {
61545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61546       };
61547     } catch (...) {
61548       {
61549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61550       };
61551     }
61552   }
61553
61554   jresult = (int)result;
61555   return jresult;
61556 }
61557
61558
61559 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_ENABLE_MARKUP_get() {
61560   int jresult ;
61561   int result;
61562
61563   {
61564     try {
61565       result = (int)Dali::Toolkit::TextVisual::Property::ENABLE_MARKUP;
61566     } catch (std::out_of_range& e) {
61567       {
61568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61569       };
61570     } catch (std::exception& e) {
61571       {
61572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61573       };
61574     } catch (Dali::DaliException e) {
61575       {
61576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61577       };
61578     } catch (...) {
61579       {
61580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61581       };
61582     }
61583   }
61584
61585   jresult = (int)result;
61586   return jresult;
61587 }
61588
61589
61590 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Builder() {
61591   void * jresult ;
61592   Dali::Toolkit::Builder *result = 0 ;
61593
61594   {
61595     try {
61596       result = (Dali::Toolkit::Builder *)new Dali::Toolkit::Builder();
61597     } catch (std::out_of_range& e) {
61598       {
61599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61600       };
61601     } catch (std::exception& e) {
61602       {
61603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61604       };
61605     } catch (Dali::DaliException e) {
61606       {
61607         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61608       };
61609     } catch (...) {
61610       {
61611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61612       };
61613     }
61614   }
61615
61616   jresult = (void *)result;
61617   return jresult;
61618 }
61619
61620
61621 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_New() {
61622   void * jresult ;
61623   Dali::Toolkit::Builder result;
61624
61625   {
61626     try {
61627       result = Dali::Toolkit::Builder::New();
61628     } catch (std::out_of_range& e) {
61629       {
61630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61631       };
61632     } catch (std::exception& e) {
61633       {
61634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61635       };
61636     } catch (Dali::DaliException e) {
61637       {
61638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61639       };
61640     } catch (...) {
61641       {
61642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61643       };
61644     }
61645   }
61646
61647   jresult = new Dali::Toolkit::Builder((const Dali::Toolkit::Builder &)result);
61648   return jresult;
61649 }
61650
61651
61652 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Builder(void * jarg1) {
61653   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61654
61655   arg1 = (Dali::Toolkit::Builder *)jarg1;
61656   {
61657     try {
61658       delete arg1;
61659     } catch (std::out_of_range& e) {
61660       {
61661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61662       };
61663     } catch (std::exception& e) {
61664       {
61665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61666       };
61667     } catch (Dali::DaliException e) {
61668       {
61669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61670       };
61671     } catch (...) {
61672       {
61673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61674       };
61675     }
61676   }
61677
61678 }
61679
61680
61681 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_0(void * jarg1, char * jarg2, int jarg3) {
61682   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61683   std::string *arg2 = 0 ;
61684   Dali::Toolkit::Builder::UIFormat arg3 ;
61685
61686   arg1 = (Dali::Toolkit::Builder *)jarg1;
61687   if (!jarg2) {
61688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61689     return ;
61690   }
61691   std::string arg2_str(jarg2);
61692   arg2 = &arg2_str;
61693   arg3 = (Dali::Toolkit::Builder::UIFormat)jarg3;
61694   {
61695     try {
61696       (arg1)->LoadFromString((std::string const &)*arg2,arg3);
61697     } catch (std::out_of_range& e) {
61698       {
61699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61700       };
61701     } catch (std::exception& e) {
61702       {
61703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61704       };
61705     } catch (Dali::DaliException e) {
61706       {
61707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61708       };
61709     } catch (...) {
61710       {
61711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61712       };
61713     }
61714   }
61715
61716
61717   //argout typemap for const std::string&
61718
61719 }
61720
61721
61722 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_1(void * jarg1, char * jarg2) {
61723   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61724   std::string *arg2 = 0 ;
61725
61726   arg1 = (Dali::Toolkit::Builder *)jarg1;
61727   if (!jarg2) {
61728     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61729     return ;
61730   }
61731   std::string arg2_str(jarg2);
61732   arg2 = &arg2_str;
61733   {
61734     try {
61735       (arg1)->LoadFromString((std::string const &)*arg2);
61736     } catch (std::out_of_range& e) {
61737       {
61738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61739       };
61740     } catch (std::exception& e) {
61741       {
61742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61743       };
61744     } catch (Dali::DaliException e) {
61745       {
61746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61747       };
61748     } catch (...) {
61749       {
61750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61751       };
61752     }
61753   }
61754
61755
61756   //argout typemap for const std::string&
61757
61758 }
61759
61760
61761 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstants(void * jarg1, void * jarg2) {
61762   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61763   Dali::Property::Map *arg2 = 0 ;
61764
61765   arg1 = (Dali::Toolkit::Builder *)jarg1;
61766   arg2 = (Dali::Property::Map *)jarg2;
61767   if (!arg2) {
61768     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
61769     return ;
61770   }
61771   {
61772     try {
61773       (arg1)->AddConstants((Dali::Property::Map const &)*arg2);
61774     } catch (std::out_of_range& e) {
61775       {
61776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61777       };
61778     } catch (std::exception& e) {
61779       {
61780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61781       };
61782     } catch (Dali::DaliException e) {
61783       {
61784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61785       };
61786     } catch (...) {
61787       {
61788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61789       };
61790     }
61791   }
61792
61793 }
61794
61795
61796 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstant(void * jarg1, char * jarg2, void * jarg3) {
61797   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61798   std::string *arg2 = 0 ;
61799   Dali::Property::Value *arg3 = 0 ;
61800
61801   arg1 = (Dali::Toolkit::Builder *)jarg1;
61802   if (!jarg2) {
61803     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61804     return ;
61805   }
61806   std::string arg2_str(jarg2);
61807   arg2 = &arg2_str;
61808   arg3 = (Dali::Property::Value *)jarg3;
61809   if (!arg3) {
61810     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
61811     return ;
61812   }
61813   {
61814     try {
61815       (arg1)->AddConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
61816     } catch (std::out_of_range& e) {
61817       {
61818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61819       };
61820     } catch (std::exception& e) {
61821       {
61822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61823       };
61824     } catch (Dali::DaliException e) {
61825       {
61826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61827       };
61828     } catch (...) {
61829       {
61830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61831       };
61832     }
61833   }
61834
61835
61836   //argout typemap for const std::string&
61837
61838 }
61839
61840
61841 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstants(void * jarg1) {
61842   void * jresult ;
61843   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61844   Dali::Property::Map *result = 0 ;
61845
61846   arg1 = (Dali::Toolkit::Builder *)jarg1;
61847   {
61848     try {
61849       result = (Dali::Property::Map *) &((Dali::Toolkit::Builder const *)arg1)->GetConstants();
61850     } catch (std::out_of_range& e) {
61851       {
61852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61853       };
61854     } catch (std::exception& e) {
61855       {
61856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61857       };
61858     } catch (Dali::DaliException e) {
61859       {
61860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61861       };
61862     } catch (...) {
61863       {
61864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61865       };
61866     }
61867   }
61868
61869   jresult = (void *)result;
61870   return jresult;
61871 }
61872
61873
61874 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstant(void * jarg1, char * jarg2) {
61875   void * jresult ;
61876   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61877   std::string *arg2 = 0 ;
61878   Dali::Property::Value *result = 0 ;
61879
61880   arg1 = (Dali::Toolkit::Builder *)jarg1;
61881   if (!jarg2) {
61882     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61883     return 0;
61884   }
61885   std::string arg2_str(jarg2);
61886   arg2 = &arg2_str;
61887   {
61888     try {
61889       result = (Dali::Property::Value *) &((Dali::Toolkit::Builder const *)arg1)->GetConstant((std::string const &)*arg2);
61890     } catch (std::out_of_range& e) {
61891       {
61892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61893       };
61894     } catch (std::exception& e) {
61895       {
61896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61897       };
61898     } catch (Dali::DaliException e) {
61899       {
61900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61901       };
61902     } catch (...) {
61903       {
61904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61905       };
61906     }
61907   }
61908
61909   jresult = (void *)result;
61910
61911   //argout typemap for const std::string&
61912
61913   return jresult;
61914 }
61915
61916
61917 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_0(void * jarg1, char * jarg2) {
61918   void * jresult ;
61919   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61920   std::string *arg2 = 0 ;
61921   Dali::Animation result;
61922
61923   arg1 = (Dali::Toolkit::Builder *)jarg1;
61924   if (!jarg2) {
61925     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61926     return 0;
61927   }
61928   std::string arg2_str(jarg2);
61929   arg2 = &arg2_str;
61930   {
61931     try {
61932       result = (arg1)->CreateAnimation((std::string const &)*arg2);
61933     } catch (std::out_of_range& e) {
61934       {
61935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61936       };
61937     } catch (std::exception& e) {
61938       {
61939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61940       };
61941     } catch (Dali::DaliException e) {
61942       {
61943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61944       };
61945     } catch (...) {
61946       {
61947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61948       };
61949     }
61950   }
61951
61952   jresult = new Dali::Animation((const Dali::Animation &)result);
61953
61954   //argout typemap for const std::string&
61955
61956   return jresult;
61957 }
61958
61959
61960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
61961   void * jresult ;
61962   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61963   std::string *arg2 = 0 ;
61964   Dali::Property::Map *arg3 = 0 ;
61965   Dali::Animation result;
61966
61967   arg1 = (Dali::Toolkit::Builder *)jarg1;
61968   if (!jarg2) {
61969     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61970     return 0;
61971   }
61972   std::string arg2_str(jarg2);
61973   arg2 = &arg2_str;
61974   arg3 = (Dali::Property::Map *)jarg3;
61975   if (!arg3) {
61976     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
61977     return 0;
61978   }
61979   {
61980     try {
61981       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
61982     } catch (std::out_of_range& e) {
61983       {
61984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61985       };
61986     } catch (std::exception& e) {
61987       {
61988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61989       };
61990     } catch (Dali::DaliException e) {
61991       {
61992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61993       };
61994     } catch (...) {
61995       {
61996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61997       };
61998     }
61999   }
62000
62001   jresult = new Dali::Animation((const Dali::Animation &)result);
62002
62003   //argout typemap for const std::string&
62004
62005   return jresult;
62006 }
62007
62008
62009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
62010   void * jresult ;
62011   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62012   std::string *arg2 = 0 ;
62013   Dali::Actor arg3 ;
62014   Dali::Actor *argp3 ;
62015   Dali::Animation result;
62016
62017   arg1 = (Dali::Toolkit::Builder *)jarg1;
62018   if (!jarg2) {
62019     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62020     return 0;
62021   }
62022   std::string arg2_str(jarg2);
62023   arg2 = &arg2_str;
62024   argp3 = (Dali::Actor *)jarg3;
62025   if (!argp3) {
62026     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62027     return 0;
62028   }
62029   arg3 = *argp3;
62030   {
62031     try {
62032       result = (arg1)->CreateAnimation((std::string const &)*arg2,arg3);
62033     } catch (std::out_of_range& e) {
62034       {
62035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62036       };
62037     } catch (std::exception& e) {
62038       {
62039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62040       };
62041     } catch (Dali::DaliException e) {
62042       {
62043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62044       };
62045     } catch (...) {
62046       {
62047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62048       };
62049     }
62050   }
62051
62052   jresult = new Dali::Animation((const Dali::Animation &)result);
62053
62054   //argout typemap for const std::string&
62055
62056   return jresult;
62057 }
62058
62059
62060 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_3(void * jarg1, char * jarg2, void * jarg3, void * jarg4) {
62061   void * jresult ;
62062   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62063   std::string *arg2 = 0 ;
62064   Dali::Property::Map *arg3 = 0 ;
62065   Dali::Actor arg4 ;
62066   Dali::Actor *argp4 ;
62067   Dali::Animation result;
62068
62069   arg1 = (Dali::Toolkit::Builder *)jarg1;
62070   if (!jarg2) {
62071     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62072     return 0;
62073   }
62074   std::string arg2_str(jarg2);
62075   arg2 = &arg2_str;
62076   arg3 = (Dali::Property::Map *)jarg3;
62077   if (!arg3) {
62078     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
62079     return 0;
62080   }
62081   argp4 = (Dali::Actor *)jarg4;
62082   if (!argp4) {
62083     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62084     return 0;
62085   }
62086   arg4 = *argp4;
62087   {
62088     try {
62089       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3,arg4);
62090     } catch (std::out_of_range& e) {
62091       {
62092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62093       };
62094     } catch (std::exception& e) {
62095       {
62096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62097       };
62098     } catch (Dali::DaliException e) {
62099       {
62100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62101       };
62102     } catch (...) {
62103       {
62104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62105       };
62106     }
62107   }
62108
62109   jresult = new Dali::Animation((const Dali::Animation &)result);
62110
62111   //argout typemap for const std::string&
62112
62113   return jresult;
62114 }
62115
62116
62117 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_0(void * jarg1, char * jarg2) {
62118   void * jresult ;
62119   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62120   std::string *arg2 = 0 ;
62121   Dali::BaseHandle result;
62122
62123   arg1 = (Dali::Toolkit::Builder *)jarg1;
62124   if (!jarg2) {
62125     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62126     return 0;
62127   }
62128   std::string arg2_str(jarg2);
62129   arg2 = &arg2_str;
62130   {
62131     try {
62132       result = (arg1)->Create((std::string const &)*arg2);
62133     } catch (std::out_of_range& e) {
62134       {
62135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62136       };
62137     } catch (std::exception& e) {
62138       {
62139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62140       };
62141     } catch (Dali::DaliException e) {
62142       {
62143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62144       };
62145     } catch (...) {
62146       {
62147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62148       };
62149     }
62150   }
62151
62152   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
62153
62154   //argout typemap for const std::string&
62155
62156   return jresult;
62157 }
62158
62159
62160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
62161   void * jresult ;
62162   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62163   std::string *arg2 = 0 ;
62164   Dali::Property::Map *arg3 = 0 ;
62165   Dali::BaseHandle result;
62166
62167   arg1 = (Dali::Toolkit::Builder *)jarg1;
62168   if (!jarg2) {
62169     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62170     return 0;
62171   }
62172   std::string arg2_str(jarg2);
62173   arg2 = &arg2_str;
62174   arg3 = (Dali::Property::Map *)jarg3;
62175   if (!arg3) {
62176     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
62177     return 0;
62178   }
62179   {
62180     try {
62181       result = (arg1)->Create((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
62182     } catch (std::out_of_range& e) {
62183       {
62184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62185       };
62186     } catch (std::exception& e) {
62187       {
62188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62189       };
62190     } catch (Dali::DaliException e) {
62191       {
62192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62193       };
62194     } catch (...) {
62195       {
62196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62197       };
62198     }
62199   }
62200
62201   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
62202
62203   //argout typemap for const std::string&
62204
62205   return jresult;
62206 }
62207
62208
62209 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateFromJson(void * jarg1, char * jarg2) {
62210   void * jresult ;
62211   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62212   std::string *arg2 = 0 ;
62213   Dali::BaseHandle result;
62214
62215   arg1 = (Dali::Toolkit::Builder *)jarg1;
62216   if (!jarg2) {
62217     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62218     return 0;
62219   }
62220   std::string arg2_str(jarg2);
62221   arg2 = &arg2_str;
62222   {
62223     try {
62224       result = (arg1)->CreateFromJson((std::string const &)*arg2);
62225     } catch (std::out_of_range& e) {
62226       {
62227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62228       };
62229     } catch (std::exception& e) {
62230       {
62231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62232       };
62233     } catch (Dali::DaliException e) {
62234       {
62235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62236       };
62237     } catch (...) {
62238       {
62239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62240       };
62241     }
62242   }
62243
62244   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
62245
62246   //argout typemap for const std::string&
62247
62248   return jresult;
62249 }
62250
62251
62252 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyStyle(void * jarg1, char * jarg2, void * jarg3) {
62253   unsigned int jresult ;
62254   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62255   std::string *arg2 = 0 ;
62256   Dali::Handle *arg3 = 0 ;
62257   bool result;
62258
62259   arg1 = (Dali::Toolkit::Builder *)jarg1;
62260   if (!jarg2) {
62261     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62262     return 0;
62263   }
62264   std::string arg2_str(jarg2);
62265   arg2 = &arg2_str;
62266   arg3 = (Dali::Handle *)jarg3;
62267   if (!arg3) {
62268     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
62269     return 0;
62270   }
62271   {
62272     try {
62273       result = (bool)(arg1)->ApplyStyle((std::string const &)*arg2,*arg3);
62274     } catch (std::out_of_range& e) {
62275       {
62276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62277       };
62278     } catch (std::exception& e) {
62279       {
62280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62281       };
62282     } catch (Dali::DaliException e) {
62283       {
62284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62285       };
62286     } catch (...) {
62287       {
62288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62289       };
62290     }
62291   }
62292
62293   jresult = result;
62294
62295   //argout typemap for const std::string&
62296
62297   return jresult;
62298 }
62299
62300
62301 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyFromJson(void * jarg1, void * jarg2, char * jarg3) {
62302   unsigned int jresult ;
62303   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62304   Dali::Handle *arg2 = 0 ;
62305   std::string *arg3 = 0 ;
62306   bool result;
62307
62308   arg1 = (Dali::Toolkit::Builder *)jarg1;
62309   arg2 = (Dali::Handle *)jarg2;
62310   if (!arg2) {
62311     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
62312     return 0;
62313   }
62314   if (!jarg3) {
62315     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62316     return 0;
62317   }
62318   std::string arg3_str(jarg3);
62319   arg3 = &arg3_str;
62320   {
62321     try {
62322       result = (bool)(arg1)->ApplyFromJson(*arg2,(std::string const &)*arg3);
62323     } catch (std::out_of_range& e) {
62324       {
62325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62326       };
62327     } catch (std::exception& e) {
62328       {
62329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62330       };
62331     } catch (Dali::DaliException e) {
62332       {
62333         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62334       };
62335     } catch (...) {
62336       {
62337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62338       };
62339     }
62340   }
62341
62342   jresult = result;
62343
62344   //argout typemap for const std::string&
62345
62346   return jresult;
62347 }
62348
62349
62350 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_0(void * jarg1, void * jarg2) {
62351   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62352   Dali::Actor arg2 ;
62353   Dali::Actor *argp2 ;
62354
62355   arg1 = (Dali::Toolkit::Builder *)jarg1;
62356   argp2 = (Dali::Actor *)jarg2;
62357   if (!argp2) {
62358     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62359     return ;
62360   }
62361   arg2 = *argp2;
62362   {
62363     try {
62364       (arg1)->AddActors(arg2);
62365     } catch (std::out_of_range& e) {
62366       {
62367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62368       };
62369     } catch (std::exception& e) {
62370       {
62371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62372       };
62373     } catch (Dali::DaliException e) {
62374       {
62375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62376       };
62377     } catch (...) {
62378       {
62379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62380       };
62381     }
62382   }
62383
62384 }
62385
62386
62387 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
62388   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62389   std::string *arg2 = 0 ;
62390   Dali::Actor arg3 ;
62391   Dali::Actor *argp3 ;
62392
62393   arg1 = (Dali::Toolkit::Builder *)jarg1;
62394   if (!jarg2) {
62395     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62396     return ;
62397   }
62398   std::string arg2_str(jarg2);
62399   arg2 = &arg2_str;
62400   argp3 = (Dali::Actor *)jarg3;
62401   if (!argp3) {
62402     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62403     return ;
62404   }
62405   arg3 = *argp3;
62406   {
62407     try {
62408       (arg1)->AddActors((std::string const &)*arg2,arg3);
62409     } catch (std::out_of_range& e) {
62410       {
62411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62412       };
62413     } catch (std::exception& e) {
62414       {
62415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62416       };
62417     } catch (Dali::DaliException e) {
62418       {
62419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62420       };
62421     } catch (...) {
62422       {
62423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62424       };
62425     }
62426   }
62427
62428
62429   //argout typemap for const std::string&
62430
62431 }
62432
62433
62434 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_CreateRenderTask(void * jarg1, char * jarg2) {
62435   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62436   std::string *arg2 = 0 ;
62437
62438   arg1 = (Dali::Toolkit::Builder *)jarg1;
62439   if (!jarg2) {
62440     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62441     return ;
62442   }
62443   std::string arg2_str(jarg2);
62444   arg2 = &arg2_str;
62445   {
62446     try {
62447       (arg1)->CreateRenderTask((std::string const &)*arg2);
62448     } catch (std::out_of_range& e) {
62449       {
62450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62451       };
62452     } catch (std::exception& e) {
62453       {
62454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62455       };
62456     } catch (Dali::DaliException e) {
62457       {
62458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62459       };
62460     } catch (...) {
62461       {
62462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62463       };
62464     }
62465   }
62466
62467
62468   //argout typemap for const std::string&
62469
62470 }
62471
62472
62473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetFrameBufferImage(void * jarg1, char * jarg2) {
62474   void * jresult ;
62475   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62476   std::string *arg2 = 0 ;
62477   Dali::FrameBufferImage result;
62478
62479   arg1 = (Dali::Toolkit::Builder *)jarg1;
62480   if (!jarg2) {
62481     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62482     return 0;
62483   }
62484   std::string arg2_str(jarg2);
62485   arg2 = &arg2_str;
62486   {
62487     try {
62488       result = (arg1)->GetFrameBufferImage((std::string const &)*arg2);
62489     } catch (std::out_of_range& e) {
62490       {
62491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62492       };
62493     } catch (std::exception& e) {
62494       {
62495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62496       };
62497     } catch (Dali::DaliException e) {
62498       {
62499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62500       };
62501     } catch (...) {
62502       {
62503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62504       };
62505     }
62506   }
62507
62508   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
62509
62510   //argout typemap for const std::string&
62511
62512   return jresult;
62513 }
62514
62515
62516 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPath(void * jarg1, char * jarg2) {
62517   void * jresult ;
62518   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62519   std::string *arg2 = 0 ;
62520   Dali::Path result;
62521
62522   arg1 = (Dali::Toolkit::Builder *)jarg1;
62523   if (!jarg2) {
62524     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62525     return 0;
62526   }
62527   std::string arg2_str(jarg2);
62528   arg2 = &arg2_str;
62529   {
62530     try {
62531       result = (arg1)->GetPath((std::string const &)*arg2);
62532     } catch (std::out_of_range& e) {
62533       {
62534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62535       };
62536     } catch (std::exception& e) {
62537       {
62538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62539       };
62540     } catch (Dali::DaliException e) {
62541       {
62542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62543       };
62544     } catch (...) {
62545       {
62546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62547       };
62548     }
62549   }
62550
62551   jresult = new Dali::Path((const Dali::Path &)result);
62552
62553   //argout typemap for const std::string&
62554
62555   return jresult;
62556 }
62557
62558
62559 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPathConstrainer(void * jarg1, char * jarg2) {
62560   void * jresult ;
62561   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62562   std::string *arg2 = 0 ;
62563   Dali::PathConstrainer result;
62564
62565   arg1 = (Dali::Toolkit::Builder *)jarg1;
62566   if (!jarg2) {
62567     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62568     return 0;
62569   }
62570   std::string arg2_str(jarg2);
62571   arg2 = &arg2_str;
62572   {
62573     try {
62574       result = (arg1)->GetPathConstrainer((std::string const &)*arg2);
62575     } catch (std::out_of_range& e) {
62576       {
62577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62578       };
62579     } catch (std::exception& e) {
62580       {
62581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62582       };
62583     } catch (Dali::DaliException e) {
62584       {
62585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62586       };
62587     } catch (...) {
62588       {
62589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62590       };
62591     }
62592   }
62593
62594   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
62595
62596   //argout typemap for const std::string&
62597
62598   return jresult;
62599 }
62600
62601
62602 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetLinearConstrainer(void * jarg1, char * jarg2) {
62603   void * jresult ;
62604   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62605   std::string *arg2 = 0 ;
62606   Dali::LinearConstrainer result;
62607
62608   arg1 = (Dali::Toolkit::Builder *)jarg1;
62609   if (!jarg2) {
62610     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62611     return 0;
62612   }
62613   std::string arg2_str(jarg2);
62614   arg2 = &arg2_str;
62615   {
62616     try {
62617       result = (arg1)->GetLinearConstrainer((std::string const &)*arg2);
62618     } catch (std::out_of_range& e) {
62619       {
62620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62621       };
62622     } catch (std::exception& e) {
62623       {
62624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62625       };
62626     } catch (Dali::DaliException e) {
62627       {
62628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62629       };
62630     } catch (...) {
62631       {
62632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62633       };
62634     }
62635   }
62636
62637   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
62638
62639   //argout typemap for const std::string&
62640
62641   return jresult;
62642 }
62643
62644
62645 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_QuitSignal(void * jarg1) {
62646   void * jresult ;
62647   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62648   Dali::Toolkit::Builder::BuilderSignalType *result = 0 ;
62649
62650   arg1 = (Dali::Toolkit::Builder *)jarg1;
62651   {
62652     try {
62653       result = (Dali::Toolkit::Builder::BuilderSignalType *) &(arg1)->QuitSignal();
62654     } catch (std::out_of_range& e) {
62655       {
62656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62657       };
62658     } catch (std::exception& e) {
62659       {
62660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62661       };
62662     } catch (Dali::DaliException e) {
62663       {
62664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62665       };
62666     } catch (...) {
62667       {
62668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62669       };
62670     }
62671   }
62672
62673   jresult = (void *)result;
62674   return jresult;
62675 }
62676
62677
62678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_0() {
62679   void * jresult ;
62680   Dali::Toolkit::TransitionData *result = 0 ;
62681
62682   {
62683     try {
62684       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData();
62685     } catch (std::out_of_range& e) {
62686       {
62687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62688       };
62689     } catch (std::exception& e) {
62690       {
62691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62692       };
62693     } catch (Dali::DaliException e) {
62694       {
62695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62696       };
62697     } catch (...) {
62698       {
62699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62700       };
62701     }
62702   }
62703
62704   jresult = (void *)result;
62705   return jresult;
62706 }
62707
62708
62709 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TransitionData(void * jarg1) {
62710   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62711
62712   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62713   {
62714     try {
62715       delete arg1;
62716     } catch (std::out_of_range& e) {
62717       {
62718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62719       };
62720     } catch (std::exception& e) {
62721       {
62722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62723       };
62724     } catch (Dali::DaliException e) {
62725       {
62726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62727       };
62728     } catch (...) {
62729       {
62730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62731       };
62732     }
62733   }
62734
62735 }
62736
62737
62738 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_0(void * jarg1) {
62739   void * jresult ;
62740   Dali::Property::Map *arg1 = 0 ;
62741   Dali::Toolkit::TransitionData result;
62742
62743   arg1 = (Dali::Property::Map *)jarg1;
62744   if (!arg1) {
62745     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
62746     return 0;
62747   }
62748   {
62749     try {
62750       result = Dali::Toolkit::TransitionData::New((Dali::Property::Map const &)*arg1);
62751     } catch (std::out_of_range& e) {
62752       {
62753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62754       };
62755     } catch (std::exception& e) {
62756       {
62757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62758       };
62759     } catch (Dali::DaliException e) {
62760       {
62761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62762       };
62763     } catch (...) {
62764       {
62765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62766       };
62767     }
62768   }
62769
62770   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
62771   return jresult;
62772 }
62773
62774
62775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_1(void * jarg1) {
62776   void * jresult ;
62777   Dali::Property::Array *arg1 = 0 ;
62778   Dali::Toolkit::TransitionData result;
62779
62780   arg1 = (Dali::Property::Array *)jarg1;
62781   if (!arg1) {
62782     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
62783     return 0;
62784   }
62785   {
62786     try {
62787       result = Dali::Toolkit::TransitionData::New((Dali::Property::Array const &)*arg1);
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 = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
62808   return jresult;
62809 }
62810
62811
62812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_DownCast(void * jarg1) {
62813   void * jresult ;
62814   Dali::BaseHandle arg1 ;
62815   Dali::BaseHandle *argp1 ;
62816   Dali::Toolkit::TransitionData result;
62817
62818   argp1 = (Dali::BaseHandle *)jarg1;
62819   if (!argp1) {
62820     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
62821     return 0;
62822   }
62823   arg1 = *argp1;
62824   {
62825     try {
62826       result = Dali::Toolkit::TransitionData::DownCast(arg1);
62827     } catch (std::out_of_range& e) {
62828       {
62829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62830       };
62831     } catch (std::exception& e) {
62832       {
62833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62834       };
62835     } catch (Dali::DaliException e) {
62836       {
62837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62838       };
62839     } catch (...) {
62840       {
62841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62842       };
62843     }
62844   }
62845
62846   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
62847   return jresult;
62848 }
62849
62850
62851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_1(void * jarg1) {
62852   void * jresult ;
62853   Dali::Toolkit::TransitionData *arg1 = 0 ;
62854   Dali::Toolkit::TransitionData *result = 0 ;
62855
62856   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62857   if (!arg1) {
62858     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
62859     return 0;
62860   }
62861   {
62862     try {
62863       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData((Dali::Toolkit::TransitionData const &)*arg1);
62864     } catch (std::out_of_range& e) {
62865       {
62866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62867       };
62868     } catch (std::exception& e) {
62869       {
62870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62871       };
62872     } catch (Dali::DaliException e) {
62873       {
62874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62875       };
62876     } catch (...) {
62877       {
62878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62879       };
62880     }
62881   }
62882
62883   jresult = (void *)result;
62884   return jresult;
62885 }
62886
62887
62888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_Assign(void * jarg1, void * jarg2) {
62889   void * jresult ;
62890   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62891   Dali::Toolkit::TransitionData *arg2 = 0 ;
62892   Dali::Toolkit::TransitionData *result = 0 ;
62893
62894   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62895   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
62896   if (!arg2) {
62897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
62898     return 0;
62899   }
62900   {
62901     try {
62902       result = (Dali::Toolkit::TransitionData *) &(arg1)->operator =((Dali::Toolkit::TransitionData const &)*arg2);
62903     } catch (std::out_of_range& e) {
62904       {
62905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62906       };
62907     } catch (std::exception& e) {
62908       {
62909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62910       };
62911     } catch (Dali::DaliException e) {
62912       {
62913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62914       };
62915     } catch (...) {
62916       {
62917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62918       };
62919     }
62920   }
62921
62922   jresult = (void *)result;
62923   return jresult;
62924 }
62925
62926
62927 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TransitionData_Count(void * jarg1) {
62928   unsigned long jresult ;
62929   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62930   size_t result;
62931
62932   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62933   {
62934     try {
62935       result = ((Dali::Toolkit::TransitionData const *)arg1)->Count();
62936     } catch (std::out_of_range& e) {
62937       {
62938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62939       };
62940     } catch (std::exception& e) {
62941       {
62942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62943       };
62944     } catch (Dali::DaliException e) {
62945       {
62946         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62947       };
62948     } catch (...) {
62949       {
62950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62951       };
62952     }
62953   }
62954
62955   jresult = (unsigned long)result;
62956   return jresult;
62957 }
62958
62959
62960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_GetAnimatorAt(void * jarg1, unsigned long jarg2) {
62961   void * jresult ;
62962   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62963   size_t arg2 ;
62964   Dali::Property::Map result;
62965
62966   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62967   arg2 = (size_t)jarg2;
62968   {
62969     try {
62970       result = (arg1)->GetAnimatorAt(arg2);
62971     } catch (std::out_of_range& e) {
62972       {
62973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62974       };
62975     } catch (std::exception& e) {
62976       {
62977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62978       };
62979     } catch (Dali::DaliException e) {
62980       {
62981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62982       };
62983     } catch (...) {
62984       {
62985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62986       };
62987     }
62988   }
62989
62990   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
62991   return jresult;
62992 }
62993
62994
62995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_2(void * jarg1) {
62996   void * jresult ;
62997   Dali::Toolkit::Internal::TransitionData *arg1 = (Dali::Toolkit::Internal::TransitionData *) 0 ;
62998   Dali::Toolkit::TransitionData *result = 0 ;
62999
63000   arg1 = (Dali::Toolkit::Internal::TransitionData *)jarg1;
63001   {
63002     try {
63003       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData(arg1);
63004     } catch (std::out_of_range& e) {
63005       {
63006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63007       };
63008     } catch (std::exception& e) {
63009       {
63010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63011       };
63012     } catch (Dali::DaliException e) {
63013       {
63014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63015       };
63016     } catch (...) {
63017       {
63018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63019       };
63020     }
63021   }
63022
63023   jresult = (void *)result;
63024   return jresult;
63025 }
63026
63027
63028 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_CONTENT_get() {
63029   int jresult ;
63030   int result;
63031
63032   {
63033     try {
63034       result = (int)Dali::Toolkit::Tooltip::Property::CONTENT;
63035     } catch (std::out_of_range& e) {
63036       {
63037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63038       };
63039     } catch (std::exception& e) {
63040       {
63041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63042       };
63043     } catch (Dali::DaliException e) {
63044       {
63045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63046       };
63047     } catch (...) {
63048       {
63049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63050       };
63051     }
63052   }
63053
63054   jresult = (int)result;
63055   return jresult;
63056 }
63057
63058
63059 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_LAYOUT_get() {
63060   int jresult ;
63061   int result;
63062
63063   {
63064     try {
63065       result = (int)Dali::Toolkit::Tooltip::Property::LAYOUT;
63066     } catch (std::out_of_range& e) {
63067       {
63068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63069       };
63070     } catch (std::exception& e) {
63071       {
63072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63073       };
63074     } catch (Dali::DaliException e) {
63075       {
63076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63077       };
63078     } catch (...) {
63079       {
63080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63081       };
63082     }
63083   }
63084
63085   jresult = (int)result;
63086   return jresult;
63087 }
63088
63089
63090 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_WAIT_TIME_get() {
63091   int jresult ;
63092   int result;
63093
63094   {
63095     try {
63096       result = (int)Dali::Toolkit::Tooltip::Property::WAIT_TIME;
63097     } catch (std::out_of_range& e) {
63098       {
63099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63100       };
63101     } catch (std::exception& e) {
63102       {
63103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63104       };
63105     } catch (Dali::DaliException e) {
63106       {
63107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63108       };
63109     } catch (...) {
63110       {
63111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63112       };
63113     }
63114   }
63115
63116   jresult = (int)result;
63117   return jresult;
63118 }
63119
63120
63121 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_get() {
63122   int jresult ;
63123   int result;
63124
63125   {
63126     try {
63127       result = (int)Dali::Toolkit::Tooltip::Property::BACKGROUND;
63128     } catch (std::out_of_range& e) {
63129       {
63130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63131       };
63132     } catch (std::exception& e) {
63133       {
63134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63135       };
63136     } catch (Dali::DaliException e) {
63137       {
63138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63139       };
63140     } catch (...) {
63141       {
63142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63143       };
63144     }
63145   }
63146
63147   jresult = (int)result;
63148   return jresult;
63149 }
63150
63151
63152 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_get() {
63153   int jresult ;
63154   int result;
63155
63156   {
63157     try {
63158       result = (int)Dali::Toolkit::Tooltip::Property::TAIL;
63159     } catch (std::out_of_range& e) {
63160       {
63161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63162       };
63163     } catch (std::exception& e) {
63164       {
63165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63166       };
63167     } catch (Dali::DaliException e) {
63168       {
63169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63170       };
63171     } catch (...) {
63172       {
63173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63174       };
63175     }
63176   }
63177
63178   jresult = (int)result;
63179   return jresult;
63180 }
63181
63182
63183 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_POSITION_get() {
63184   int jresult ;
63185   int result;
63186
63187   {
63188     try {
63189       result = (int)Dali::Toolkit::Tooltip::Property::POSITION;
63190     } catch (std::out_of_range& e) {
63191       {
63192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63193       };
63194     } catch (std::exception& e) {
63195       {
63196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63197       };
63198     } catch (Dali::DaliException e) {
63199       {
63200         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63201       };
63202     } catch (...) {
63203       {
63204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63205       };
63206     }
63207   }
63208
63209   jresult = (int)result;
63210   return jresult;
63211 }
63212
63213
63214 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_HOVER_POINT_OFFSET_get() {
63215   int jresult ;
63216   int result;
63217
63218   {
63219     try {
63220       result = (int)Dali::Toolkit::Tooltip::Property::HOVER_POINT_OFFSET;
63221     } catch (std::out_of_range& e) {
63222       {
63223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63224       };
63225     } catch (std::exception& e) {
63226       {
63227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63228       };
63229     } catch (Dali::DaliException e) {
63230       {
63231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63232       };
63233     } catch (...) {
63234       {
63235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63236       };
63237     }
63238   }
63239
63240   jresult = (int)result;
63241   return jresult;
63242 }
63243
63244
63245 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_MOVEMENT_THRESHOLD_get() {
63246   int jresult ;
63247   int result;
63248
63249   {
63250     try {
63251       result = (int)Dali::Toolkit::Tooltip::Property::MOVEMENT_THRESHOLD;
63252     } catch (std::out_of_range& e) {
63253       {
63254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63255       };
63256     } catch (std::exception& e) {
63257       {
63258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63259       };
63260     } catch (Dali::DaliException e) {
63261       {
63262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63263       };
63264     } catch (...) {
63265       {
63266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63267       };
63268     }
63269   }
63270
63271   jresult = (int)result;
63272   return jresult;
63273 }
63274
63275
63276 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_DISAPPEAR_ON_MOVEMENT_get() {
63277   int jresult ;
63278   int result;
63279
63280   {
63281     try {
63282       result = (int)Dali::Toolkit::Tooltip::Property::DISAPPEAR_ON_MOVEMENT;
63283     } catch (std::out_of_range& e) {
63284       {
63285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63286       };
63287     } catch (std::exception& e) {
63288       {
63289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63290       };
63291     } catch (Dali::DaliException e) {
63292       {
63293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63294       };
63295     } catch (...) {
63296       {
63297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63298       };
63299     }
63300   }
63301
63302   jresult = (int)result;
63303   return jresult;
63304 }
63305
63306
63307 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_VISUAL_get() {
63308   int jresult ;
63309   int result;
63310
63311   {
63312     try {
63313       result = (int)Dali::Toolkit::Tooltip::Background::Property::VISUAL;
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 = (int)result;
63334   return jresult;
63335 }
63336
63337
63338 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_BORDER_get() {
63339   int jresult ;
63340   int result;
63341
63342   {
63343     try {
63344       result = (int)Dali::Toolkit::Tooltip::Background::Property::BORDER;
63345     } catch (std::out_of_range& e) {
63346       {
63347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63348       };
63349     } catch (std::exception& e) {
63350       {
63351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63352       };
63353     } catch (Dali::DaliException e) {
63354       {
63355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63356       };
63357     } catch (...) {
63358       {
63359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63360       };
63361     }
63362   }
63363
63364   jresult = (int)result;
63365   return jresult;
63366 }
63367
63368
63369 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_VISIBILITY_get() {
63370   int jresult ;
63371   int result;
63372
63373   {
63374     try {
63375       result = (int)Dali::Toolkit::Tooltip::Tail::Property::VISIBILITY;
63376     } catch (std::out_of_range& e) {
63377       {
63378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63379       };
63380     } catch (std::exception& e) {
63381       {
63382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63383       };
63384     } catch (Dali::DaliException e) {
63385       {
63386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63387       };
63388     } catch (...) {
63389       {
63390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63391       };
63392     }
63393   }
63394
63395   jresult = (int)result;
63396   return jresult;
63397 }
63398
63399
63400 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_ABOVE_VISUAL_get() {
63401   int jresult ;
63402   int result;
63403
63404   {
63405     try {
63406       result = (int)Dali::Toolkit::Tooltip::Tail::Property::ABOVE_VISUAL;
63407     } catch (std::out_of_range& e) {
63408       {
63409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63410       };
63411     } catch (std::exception& e) {
63412       {
63413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63414       };
63415     } catch (Dali::DaliException e) {
63416       {
63417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63418       };
63419     } catch (...) {
63420       {
63421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63422       };
63423     }
63424   }
63425
63426   jresult = (int)result;
63427   return jresult;
63428 }
63429
63430
63431 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_BELOW_VISUAL_get() {
63432   int jresult ;
63433   int result;
63434
63435   {
63436     try {
63437       result = (int)Dali::Toolkit::Tooltip::Tail::Property::BELOW_VISUAL;
63438     } catch (std::out_of_range& e) {
63439       {
63440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63441       };
63442     } catch (std::exception& e) {
63443       {
63444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63445       };
63446     } catch (Dali::DaliException e) {
63447       {
63448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63449       };
63450     } catch (...) {
63451       {
63452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63453       };
63454     }
63455   }
63456
63457   jresult = (int)result;
63458   return jresult;
63459 }
63460
63461
63462 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_New() {
63463   void * jresult ;
63464   Dali::Toolkit::Control result;
63465
63466   {
63467     try {
63468       result = Dali::Toolkit::Internal::Control::New();
63469     } catch (std::out_of_range& e) {
63470       {
63471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63472       };
63473     } catch (std::exception& e) {
63474       {
63475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63476       };
63477     } catch (Dali::DaliException e) {
63478       {
63479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63480       };
63481     } catch (...) {
63482       {
63483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63484       };
63485     }
63486   }
63487
63488   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
63489   return jresult;
63490 }
63491
63492
63493 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetStyleName(void * jarg1, char * jarg2) {
63494   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63495   std::string *arg2 = 0 ;
63496
63497   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63498   if (!jarg2) {
63499     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
63500     return ;
63501   }
63502   std::string arg2_str(jarg2);
63503   arg2 = &arg2_str;
63504   {
63505     try {
63506       (arg1)->SetStyleName((std::string const &)*arg2);
63507     } catch (std::out_of_range& e) {
63508       {
63509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63510       };
63511     } catch (std::exception& e) {
63512       {
63513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63514       };
63515     } catch (Dali::DaliException e) {
63516       {
63517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63518       };
63519     } catch (...) {
63520       {
63521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63522       };
63523     }
63524   }
63525
63526
63527   //argout typemap for const std::string&
63528
63529 }
63530
63531
63532 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ViewImpl_GetStyleName(void * jarg1) {
63533   char * jresult ;
63534   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63535   std::string *result = 0 ;
63536
63537   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63538   {
63539     try {
63540       result = (std::string *) &((Dali::Toolkit::Internal::Control const *)arg1)->GetStyleName();
63541     } catch (std::out_of_range& e) {
63542       {
63543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63544       };
63545     } catch (std::exception& e) {
63546       {
63547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63548       };
63549     } catch (Dali::DaliException e) {
63550       {
63551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63552       };
63553     } catch (...) {
63554       {
63555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63556       };
63557     }
63558   }
63559
63560   jresult = SWIG_csharp_string_callback(result->c_str());
63561   return jresult;
63562 }
63563
63564
63565 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundColor(void * jarg1, void * jarg2) {
63566   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63567   Dali::Vector4 *arg2 = 0 ;
63568
63569   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63570   arg2 = (Dali::Vector4 *)jarg2;
63571   if (!arg2) {
63572     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
63573     return ;
63574   }
63575   {
63576     try {
63577       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
63578     } catch (std::out_of_range& e) {
63579       {
63580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63581       };
63582     } catch (std::exception& e) {
63583       {
63584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63585       };
63586     } catch (Dali::DaliException e) {
63587       {
63588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63589       };
63590     } catch (...) {
63591       {
63592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63593       };
63594     }
63595   }
63596
63597 }
63598
63599
63600 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetBackgroundColor(void * jarg1) {
63601   void * jresult ;
63602   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63603   Dali::Vector4 result;
63604
63605   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63606   {
63607     try {
63608       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetBackgroundColor();
63609     } catch (std::out_of_range& e) {
63610       {
63611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63612       };
63613     } catch (std::exception& e) {
63614       {
63615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63616       };
63617     } catch (Dali::DaliException e) {
63618       {
63619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63620       };
63621     } catch (...) {
63622       {
63623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63624       };
63625     }
63626   }
63627
63628   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
63629   return jresult;
63630 }
63631
63632
63633 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundImage(void * jarg1, void * jarg2) {
63634   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63635   Dali::Image arg2 ;
63636   Dali::Image *argp2 ;
63637
63638   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63639   argp2 = (Dali::Image *)jarg2;
63640   if (!argp2) {
63641     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
63642     return ;
63643   }
63644   arg2 = *argp2;
63645   {
63646     try {
63647       (arg1)->SetBackgroundImage(arg2);
63648     } catch (std::out_of_range& e) {
63649       {
63650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63651       };
63652     } catch (std::exception& e) {
63653       {
63654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63655       };
63656     } catch (Dali::DaliException e) {
63657       {
63658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63659       };
63660     } catch (...) {
63661       {
63662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63663       };
63664     }
63665   }
63666
63667 }
63668
63669
63670 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackground(void * jarg1, void * jarg2) {
63671   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63672   Dali::Property::Map *arg2 = 0 ;
63673
63674   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63675   arg2 = (Dali::Property::Map *)jarg2;
63676   if (!arg2) {
63677     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
63678     return ;
63679   }
63680   {
63681     try {
63682       (arg1)->SetBackground((Dali::Property::Map const &)*arg2);
63683     } catch (std::out_of_range& e) {
63684       {
63685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63686       };
63687     } catch (std::exception& e) {
63688       {
63689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63690       };
63691     } catch (Dali::DaliException e) {
63692       {
63693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63694       };
63695     } catch (...) {
63696       {
63697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63698       };
63699     }
63700   }
63701
63702 }
63703
63704
63705 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearBackground(void * jarg1) {
63706   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63707
63708   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63709   {
63710     try {
63711       (arg1)->ClearBackground();
63712     } catch (std::out_of_range& e) {
63713       {
63714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63715       };
63716     } catch (std::exception& e) {
63717       {
63718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63719       };
63720     } catch (Dali::DaliException e) {
63721       {
63722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63723       };
63724     } catch (...) {
63725       {
63726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63727       };
63728     }
63729   }
63730
63731 }
63732
63733
63734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_EnableGestureDetection(void * jarg1, int jarg2) {
63735   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63736   Dali::Gesture::Type arg2 ;
63737
63738   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63739   arg2 = (Dali::Gesture::Type)jarg2;
63740   {
63741     try {
63742       (arg1)->EnableGestureDetection(arg2);
63743     } catch (std::out_of_range& e) {
63744       {
63745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63746       };
63747     } catch (std::exception& e) {
63748       {
63749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63750       };
63751     } catch (Dali::DaliException e) {
63752       {
63753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63754       };
63755     } catch (...) {
63756       {
63757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63758       };
63759     }
63760   }
63761
63762 }
63763
63764
63765 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_DisableGestureDetection(void * jarg1, int jarg2) {
63766   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63767   Dali::Gesture::Type arg2 ;
63768
63769   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63770   arg2 = (Dali::Gesture::Type)jarg2;
63771   {
63772     try {
63773       (arg1)->DisableGestureDetection(arg2);
63774     } catch (std::out_of_range& e) {
63775       {
63776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63777       };
63778     } catch (std::exception& e) {
63779       {
63780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63781       };
63782     } catch (Dali::DaliException e) {
63783       {
63784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63785       };
63786     } catch (...) {
63787       {
63788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63789       };
63790     }
63791   }
63792
63793 }
63794
63795
63796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPinchGestureDetector(void * jarg1) {
63797   void * jresult ;
63798   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63799   Dali::PinchGestureDetector result;
63800
63801   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63802   {
63803     try {
63804       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPinchGestureDetector();
63805     } catch (std::out_of_range& e) {
63806       {
63807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63808       };
63809     } catch (std::exception& e) {
63810       {
63811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63812       };
63813     } catch (Dali::DaliException e) {
63814       {
63815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63816       };
63817     } catch (...) {
63818       {
63819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63820       };
63821     }
63822   }
63823
63824   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
63825   return jresult;
63826 }
63827
63828
63829 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPanGestureDetector(void * jarg1) {
63830   void * jresult ;
63831   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63832   Dali::PanGestureDetector result;
63833
63834   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63835   {
63836     try {
63837       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPanGestureDetector();
63838     } catch (std::out_of_range& e) {
63839       {
63840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63841       };
63842     } catch (std::exception& e) {
63843       {
63844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63845       };
63846     } catch (Dali::DaliException e) {
63847       {
63848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63849       };
63850     } catch (...) {
63851       {
63852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63853       };
63854     }
63855   }
63856
63857   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
63858   return jresult;
63859 }
63860
63861
63862 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetTapGestureDetector(void * jarg1) {
63863   void * jresult ;
63864   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63865   Dali::TapGestureDetector result;
63866
63867   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63868   {
63869     try {
63870       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetTapGestureDetector();
63871     } catch (std::out_of_range& e) {
63872       {
63873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63874       };
63875     } catch (std::exception& e) {
63876       {
63877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63878       };
63879     } catch (Dali::DaliException e) {
63880       {
63881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63882       };
63883     } catch (...) {
63884       {
63885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63886       };
63887     }
63888   }
63889
63890   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
63891   return jresult;
63892 }
63893
63894
63895 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetLongPressGestureDetector(void * jarg1) {
63896   void * jresult ;
63897   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63898   Dali::LongPressGestureDetector result;
63899
63900   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63901   {
63902     try {
63903       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetLongPressGestureDetector();
63904     } catch (std::out_of_range& e) {
63905       {
63906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63907       };
63908     } catch (std::exception& e) {
63909       {
63910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63911       };
63912     } catch (Dali::DaliException e) {
63913       {
63914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63915       };
63916     } catch (...) {
63917       {
63918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63919       };
63920     }
63921   }
63922
63923   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
63924   return jresult;
63925 }
63926
63927
63928 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyboardNavigationSupport(void * jarg1, unsigned int jarg2) {
63929   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63930   bool arg2 ;
63931
63932   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63933   arg2 = jarg2 ? true : false;
63934   {
63935     try {
63936       (arg1)->SetKeyboardNavigationSupport(arg2);
63937     } catch (std::out_of_range& e) {
63938       {
63939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63940       };
63941     } catch (std::exception& e) {
63942       {
63943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63944       };
63945     } catch (Dali::DaliException e) {
63946       {
63947         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63948       };
63949     } catch (...) {
63950       {
63951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63952       };
63953     }
63954   }
63955
63956 }
63957
63958
63959 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardNavigationSupported(void * jarg1) {
63960   unsigned int jresult ;
63961   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63962   bool result;
63963
63964   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63965   {
63966     try {
63967       result = (bool)(arg1)->IsKeyboardNavigationSupported();
63968     } catch (std::out_of_range& e) {
63969       {
63970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63971       };
63972     } catch (std::exception& e) {
63973       {
63974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63975       };
63976     } catch (Dali::DaliException e) {
63977       {
63978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63979       };
63980     } catch (...) {
63981       {
63982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63983       };
63984     }
63985   }
63986
63987   jresult = result;
63988   return jresult;
63989 }
63990
63991
63992 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyInputFocus(void * jarg1) {
63993   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63994
63995   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63996   {
63997     try {
63998       (arg1)->SetKeyInputFocus();
63999     } catch (std::out_of_range& e) {
64000       {
64001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64002       };
64003     } catch (std::exception& e) {
64004       {
64005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64006       };
64007     } catch (Dali::DaliException e) {
64008       {
64009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64010       };
64011     } catch (...) {
64012       {
64013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64014       };
64015     }
64016   }
64017
64018 }
64019
64020
64021 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_HasKeyInputFocus(void * jarg1) {
64022   unsigned int jresult ;
64023   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64024   bool result;
64025
64026   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64027   {
64028     try {
64029       result = (bool)(arg1)->HasKeyInputFocus();
64030     } catch (std::out_of_range& e) {
64031       {
64032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64033       };
64034     } catch (std::exception& e) {
64035       {
64036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64037       };
64038     } catch (Dali::DaliException e) {
64039       {
64040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64041       };
64042     } catch (...) {
64043       {
64044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64045       };
64046     }
64047   }
64048
64049   jresult = result;
64050   return jresult;
64051 }
64052
64053
64054 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearKeyInputFocus(void * jarg1) {
64055   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64056
64057   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64058   {
64059     try {
64060       (arg1)->ClearKeyInputFocus();
64061     } catch (std::out_of_range& e) {
64062       {
64063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64064       };
64065     } catch (std::exception& e) {
64066       {
64067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64068       };
64069     } catch (Dali::DaliException e) {
64070       {
64071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64072       };
64073     } catch (...) {
64074       {
64075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64076       };
64077     }
64078   }
64079
64080 }
64081
64082
64083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetAsKeyboardFocusGroup(void * jarg1, unsigned int jarg2) {
64084   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64085   bool arg2 ;
64086
64087   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64088   arg2 = jarg2 ? true : false;
64089   {
64090     try {
64091       (arg1)->SetAsKeyboardFocusGroup(arg2);
64092     } catch (std::out_of_range& e) {
64093       {
64094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64095       };
64096     } catch (std::exception& e) {
64097       {
64098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64099       };
64100     } catch (Dali::DaliException e) {
64101       {
64102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64103       };
64104     } catch (...) {
64105       {
64106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64107       };
64108     }
64109   }
64110
64111 }
64112
64113
64114 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardFocusGroup(void * jarg1) {
64115   unsigned int jresult ;
64116   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64117   bool result;
64118
64119   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64120   {
64121     try {
64122       result = (bool)(arg1)->IsKeyboardFocusGroup();
64123     } catch (std::out_of_range& e) {
64124       {
64125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64126       };
64127     } catch (std::exception& e) {
64128       {
64129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64130       };
64131     } catch (Dali::DaliException e) {
64132       {
64133         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64134       };
64135     } catch (...) {
64136       {
64137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64138       };
64139     }
64140   }
64141
64142   jresult = result;
64143   return jresult;
64144 }
64145
64146
64147 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_AccessibilityActivate(void * jarg1) {
64148   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64149
64150   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64151   {
64152     try {
64153       (arg1)->AccessibilityActivate();
64154     } catch (std::out_of_range& e) {
64155       {
64156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64157       };
64158     } catch (std::exception& e) {
64159       {
64160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64161       };
64162     } catch (Dali::DaliException e) {
64163       {
64164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64165       };
64166     } catch (...) {
64167       {
64168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64169       };
64170     }
64171   }
64172
64173 }
64174
64175
64176 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_KeyboardEnter(void * jarg1) {
64177   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64178
64179   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64180   {
64181     try {
64182       (arg1)->KeyboardEnter();
64183     } catch (std::out_of_range& e) {
64184       {
64185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64186       };
64187     } catch (std::exception& e) {
64188       {
64189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64190       };
64191     } catch (Dali::DaliException e) {
64192       {
64193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64194       };
64195     } catch (...) {
64196       {
64197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64198       };
64199     }
64200   }
64201
64202 }
64203
64204
64205 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyEventSignal(void * jarg1) {
64206   void * jresult ;
64207   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64208   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
64209
64210   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64211   {
64212     try {
64213       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
64214     } catch (std::out_of_range& e) {
64215       {
64216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64217       };
64218     } catch (std::exception& e) {
64219       {
64220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64221       };
64222     } catch (Dali::DaliException e) {
64223       {
64224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64225       };
64226     } catch (...) {
64227       {
64228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64229       };
64230     }
64231   }
64232
64233   jresult = (void *)result;
64234   return jresult;
64235 }
64236
64237
64238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusGainedSignal(void * jarg1) {
64239   void * jresult ;
64240   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64241   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
64242
64243   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64244   {
64245     try {
64246       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
64247     } catch (std::out_of_range& e) {
64248       {
64249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64250       };
64251     } catch (std::exception& e) {
64252       {
64253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64254       };
64255     } catch (Dali::DaliException e) {
64256       {
64257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64258       };
64259     } catch (...) {
64260       {
64261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64262       };
64263     }
64264   }
64265
64266   jresult = (void *)result;
64267   return jresult;
64268 }
64269
64270
64271 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusLostSignal(void * jarg1) {
64272   void * jresult ;
64273   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64274   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
64275
64276   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64277   {
64278     try {
64279       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
64280     } catch (std::out_of_range& e) {
64281       {
64282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64283       };
64284     } catch (std::exception& e) {
64285       {
64286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64287       };
64288     } catch (Dali::DaliException e) {
64289       {
64290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64291       };
64292     } catch (...) {
64293       {
64294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64295       };
64296     }
64297   }
64298
64299   jresult = (void *)result;
64300   return jresult;
64301 }
64302
64303
64304 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_EmitKeyEventSignal(void * jarg1, void * jarg2) {
64305   unsigned int jresult ;
64306   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64307   Dali::KeyEvent *arg2 = 0 ;
64308   bool result;
64309
64310   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64311   arg2 = (Dali::KeyEvent *)jarg2;
64312   if (!arg2) {
64313     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
64314     return 0;
64315   }
64316   {
64317     try {
64318       result = (bool)(arg1)->EmitKeyEventSignal((Dali::KeyEvent const &)*arg2);
64319     } catch (std::out_of_range& e) {
64320       {
64321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64322       };
64323     } catch (std::exception& e) {
64324       {
64325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64326       };
64327     } catch (Dali::DaliException e) {
64328       {
64329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64330       };
64331     } catch (...) {
64332       {
64333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64334       };
64335     }
64336   }
64337
64338   jresult = result;
64339   return jresult;
64340 }
64341
64342
64343 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnection(void * jarg1, int jarg2) {
64344   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64345   int arg2 ;
64346   SwigDirector_ViewImpl *darg = 0;
64347
64348   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64349   arg2 = (int)jarg2;
64350   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64351   {
64352     try {
64353       if(darg) {
64354         (darg)->OnStageConnection(arg2);
64355       }
64356     } catch (std::out_of_range& e) {
64357       {
64358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64359       };
64360     } catch (std::exception& e) {
64361       {
64362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64363       };
64364     } catch (Dali::DaliException e) {
64365       {
64366         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64367       };
64368     } catch (...) {
64369       {
64370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64371       };
64372     }
64373   }
64374
64375 }
64376
64377
64378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnectionSwigExplicitViewImpl(void * jarg1, int jarg2) {
64379   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64380   int arg2 ;
64381   SwigDirector_ViewImpl *darg = 0;
64382
64383   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64384   arg2 = (int)jarg2;
64385   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64386   {
64387     try {
64388       if(darg) {
64389         (darg)->OnStageConnectionSwigPublic(arg2);
64390       }
64391     } catch (std::out_of_range& e) {
64392       {
64393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64394       };
64395     } catch (std::exception& e) {
64396       {
64397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64398       };
64399     } catch (Dali::DaliException e) {
64400       {
64401         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64402       };
64403     } catch (...) {
64404       {
64405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64406       };
64407     }
64408   }
64409
64410 }
64411
64412
64413 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnection(void * jarg1) {
64414   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64415   SwigDirector_ViewImpl *darg = 0;
64416
64417   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64418   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64419   {
64420     try {
64421       if(darg) {
64422         (darg)->OnStageDisconnection();
64423       }
64424     } catch (std::out_of_range& e) {
64425       {
64426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64427       };
64428     } catch (std::exception& e) {
64429       {
64430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64431       };
64432     } catch (Dali::DaliException e) {
64433       {
64434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64435       };
64436     } catch (...) {
64437       {
64438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64439       };
64440     }
64441   }
64442
64443 }
64444
64445
64446 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnectionSwigExplicitViewImpl(void * jarg1) {
64447   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64448   SwigDirector_ViewImpl *darg = 0;
64449
64450   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64451   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64452   {
64453     try {
64454       if(darg) {
64455         (darg)->OnStageDisconnectionSwigPublic();
64456       }
64457     } catch (std::out_of_range& e) {
64458       {
64459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64460       };
64461     } catch (std::exception& e) {
64462       {
64463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64464       };
64465     } catch (Dali::DaliException e) {
64466       {
64467         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64468       };
64469     } catch (...) {
64470       {
64471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64472       };
64473     }
64474   }
64475
64476 }
64477
64478
64479 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAdd(void * jarg1, void * jarg2) {
64480   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64481   Dali::Actor *arg2 = 0 ;
64482   SwigDirector_ViewImpl *darg = 0;
64483
64484   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64485   arg2 = (Dali::Actor *)jarg2;
64486   if (!arg2) {
64487     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
64488     return ;
64489   }
64490   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64491   {
64492     try {
64493       if(darg) {
64494         (darg)->OnChildAdd(*arg2);
64495       }
64496     } catch (std::out_of_range& e) {
64497       {
64498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64499       };
64500     } catch (std::exception& e) {
64501       {
64502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64503       };
64504     } catch (Dali::DaliException e) {
64505       {
64506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64507       };
64508     } catch (...) {
64509       {
64510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64511       };
64512     }
64513   }
64514
64515 }
64516
64517
64518 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64519   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64520   Dali::Actor *arg2 = 0 ;
64521   SwigDirector_ViewImpl *darg = 0;
64522
64523   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64524   arg2 = (Dali::Actor *)jarg2;
64525   if (!arg2) {
64526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
64527     return ;
64528   }
64529   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64530   {
64531     try {
64532       if(darg) {
64533           (darg)->OnChildAddSwigPublic(*arg2);
64534       }
64535     } catch (std::out_of_range& e) {
64536       {
64537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64538       };
64539     } catch (std::exception& e) {
64540       {
64541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64542       };
64543     } catch (Dali::DaliException e) {
64544       {
64545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64546       };
64547     } catch (...) {
64548       {
64549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64550       };
64551     }
64552   }
64553
64554 }
64555
64556
64557 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemove(void * jarg1, void * jarg2) {
64558   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64559   Dali::Actor *arg2 = 0 ;
64560   SwigDirector_ViewImpl *darg = 0;
64561
64562   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64563   arg2 = (Dali::Actor *)jarg2;
64564   if (!arg2) {
64565     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
64566     return ;
64567   }
64568   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64569   {
64570     try {
64571       if(darg) {
64572         (darg)->OnChildRemove(*arg2);
64573       }
64574     } catch (std::out_of_range& e) {
64575       {
64576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64577       };
64578     } catch (std::exception& e) {
64579       {
64580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64581       };
64582     } catch (Dali::DaliException e) {
64583       {
64584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64585       };
64586     } catch (...) {
64587       {
64588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64589       };
64590     }
64591   }
64592
64593 }
64594
64595
64596 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64597   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64598   Dali::Actor *arg2 = 0 ;
64599   SwigDirector_ViewImpl *darg = 0;
64600
64601   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64602   arg2 = (Dali::Actor *)jarg2;
64603   if (!arg2) {
64604     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
64605     return ;
64606   }
64607   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64608   {
64609     try {
64610       if(darg) {
64611         (darg)->OnChildRemoveSwigPublic(*arg2);
64612       }
64613     } catch (std::out_of_range& e) {
64614       {
64615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64616       };
64617     } catch (std::exception& e) {
64618       {
64619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64620       };
64621     } catch (Dali::DaliException e) {
64622       {
64623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64624       };
64625     } catch (...) {
64626       {
64627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64628       };
64629     }
64630   }
64631
64632 }
64633
64634
64635 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
64636   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64637   Dali::Property::Index arg2 ;
64638   Dali::Property::Value arg3 ;
64639   Dali::Property::Value *argp3 ;
64640   SwigDirector_ViewImpl *darg = 0;
64641
64642   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64643   arg2 = (Dali::Property::Index)jarg2;
64644   argp3 = (Dali::Property::Value *)jarg3;
64645   if (!argp3) {
64646     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
64647     return ;
64648   }
64649   arg3 = *argp3;
64650   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64651   if (!darg) {
64652     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64653     return;
64654   }
64655   {
64656     try {
64657       (darg)->OnPropertySet(arg2,arg3);
64658     } catch (std::out_of_range& e) {
64659       {
64660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64661       };
64662     } catch (std::exception& e) {
64663       {
64664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64665       };
64666     } catch (Dali::DaliException e) {
64667       {
64668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64669       };
64670     } catch (...) {
64671       {
64672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64673       };
64674     }
64675   }
64676
64677 }
64678
64679
64680 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySetSwigExplicitViewImpl(void * jarg1, int jarg2, void * jarg3) {
64681   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64682   Dali::Property::Index arg2 ;
64683   Dali::Property::Value arg3 ;
64684   Dali::Property::Value *argp3 ;
64685   SwigDirector_ViewImpl *darg = 0;
64686
64687   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64688   arg2 = (Dali::Property::Index)jarg2;
64689   argp3 = (Dali::Property::Value *)jarg3;
64690   if (!argp3) {
64691     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
64692     return ;
64693   }
64694   arg3 = *argp3;
64695   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64696   if (!darg) {
64697     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64698     return;
64699   }
64700   {
64701     try {
64702       (darg)->OnPropertySetSwigPublic(arg2,arg3);
64703     } catch (std::out_of_range& e) {
64704       {
64705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64706       };
64707     } catch (std::exception& e) {
64708       {
64709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64710       };
64711     } catch (Dali::DaliException e) {
64712       {
64713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64714       };
64715     } catch (...) {
64716       {
64717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64718       };
64719     }
64720   }
64721
64722 }
64723
64724
64725 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSet(void * jarg1, void * jarg2) {
64726   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64727   Dali::Vector3 *arg2 = 0 ;
64728   SwigDirector_ViewImpl *darg = 0;
64729
64730   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64731   arg2 = (Dali::Vector3 *)jarg2;
64732   if (!arg2) {
64733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64734     return ;
64735   }
64736   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64737   if (!darg) {
64738     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64739     return;
64740   }
64741   {
64742     try {
64743       (darg)->OnSizeSet((Dali::Vector3 const &)*arg2);
64744     } catch (std::out_of_range& e) {
64745       {
64746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64747       };
64748     } catch (std::exception& e) {
64749       {
64750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64751       };
64752     } catch (Dali::DaliException e) {
64753       {
64754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64755       };
64756     } catch (...) {
64757       {
64758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64759       };
64760     }
64761   }
64762
64763 }
64764
64765
64766 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSetSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64767   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64768   Dali::Vector3 *arg2 = 0 ;
64769   SwigDirector_ViewImpl *darg = 0;
64770
64771   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64772   arg2 = (Dali::Vector3 *)jarg2;
64773   if (!arg2) {
64774     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64775     return ;
64776   }
64777   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64778   if (!darg) {
64779     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64780     return;
64781   }
64782   {
64783     try {
64784       (darg)->OnSizeSetSwigPublic((Dali::Vector3 const &)*arg2);
64785     } catch (std::out_of_range& e) {
64786       {
64787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64788       };
64789     } catch (std::exception& e) {
64790       {
64791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64792       };
64793     } catch (Dali::DaliException e) {
64794       {
64795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64796       };
64797     } catch (...) {
64798       {
64799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64800       };
64801     }
64802   }
64803
64804 }
64805
64806
64807 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
64808   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64809   Dali::Animation *arg2 = 0 ;
64810   Dali::Vector3 *arg3 = 0 ;
64811   SwigDirector_ViewImpl *darg = 0;
64812
64813   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64814   arg2 = (Dali::Animation *)jarg2;
64815   if (!arg2) {
64816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
64817     return ;
64818   }
64819   arg3 = (Dali::Vector3 *)jarg3;
64820   if (!arg3) {
64821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64822     return ;
64823   }
64824   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64825   if (!darg) {
64826     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64827     return;
64828   }
64829   {
64830     try {
64831       (darg)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
64832     } catch (std::out_of_range& e) {
64833       {
64834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64835       };
64836     } catch (std::exception& e) {
64837       {
64838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64839       };
64840     } catch (Dali::DaliException e) {
64841       {
64842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64843       };
64844     } catch (...) {
64845       {
64846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64847       };
64848     }
64849   }
64850
64851 }
64852
64853
64854 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimationSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
64855   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64856   Dali::Animation *arg2 = 0 ;
64857   Dali::Vector3 *arg3 = 0 ;
64858   SwigDirector_ViewImpl *darg = 0;
64859
64860   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64861   arg2 = (Dali::Animation *)jarg2;
64862   if (!arg2) {
64863     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
64864     return ;
64865   }
64866   arg3 = (Dali::Vector3 *)jarg3;
64867   if (!arg3) {
64868     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64869     return ;
64870   }
64871   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64872   if (!darg) {
64873     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64874     return;
64875   }
64876   {
64877     try {
64878       (darg)->OnSizeAnimationSwigPublic(*arg2,(Dali::Vector3 const &)*arg3);
64879     } catch (std::out_of_range& e) {
64880       {
64881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64882       };
64883     } catch (std::exception& e) {
64884       {
64885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64886       };
64887     } catch (Dali::DaliException e) {
64888       {
64889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64890       };
64891     } catch (...) {
64892       {
64893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64894       };
64895     }
64896   }
64897
64898 }
64899
64900
64901 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEvent(void * jarg1, void * jarg2) {
64902   unsigned int jresult ;
64903   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64904   Dali::TouchEvent *arg2 = 0 ;
64905   SwigDirector_ViewImpl *darg = 0;
64906   bool result;
64907
64908   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64909   arg2 = (Dali::TouchEvent *)jarg2;
64910   if (!arg2) {
64911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
64912     return 0;
64913   }
64914   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64915   if (!darg) {
64916     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64917     return 0;
64918   }
64919   {
64920     try {
64921       result = (bool)(darg)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
64922     } catch (std::out_of_range& e) {
64923       {
64924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64925       };
64926     } catch (std::exception& e) {
64927       {
64928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64929       };
64930     } catch (Dali::DaliException e) {
64931       {
64932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64933       };
64934     } catch (...) {
64935       {
64936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64937       };
64938     }
64939   }
64940
64941   jresult = result;
64942   return jresult;
64943 }
64944
64945
64946 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64947   unsigned int jresult ;
64948   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64949   Dali::TouchEvent *arg2 = 0 ;
64950   SwigDirector_ViewImpl *darg = 0;
64951   bool result;
64952
64953   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64954   arg2 = (Dali::TouchEvent *)jarg2;
64955   if (!arg2) {
64956     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
64957     return 0;
64958   }
64959   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64960   if (!darg) {
64961     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64962     return 0;
64963   }
64964   {
64965     try {
64966       result = (bool)(darg)->OnTouchEventSwigPublic((Dali::TouchEvent const &)*arg2);
64967     } catch (std::out_of_range& e) {
64968       {
64969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64970       };
64971     } catch (std::exception& e) {
64972       {
64973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64974       };
64975     } catch (Dali::DaliException e) {
64976       {
64977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64978       };
64979     } catch (...) {
64980       {
64981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64982       };
64983     }
64984   }
64985
64986   jresult = result;
64987   return jresult;
64988 }
64989
64990
64991 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEvent(void * jarg1, void * jarg2) {
64992   unsigned int jresult ;
64993   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64994   Dali::HoverEvent *arg2 = 0 ;
64995   SwigDirector_ViewImpl *darg = 0;
64996   bool result;
64997
64998   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64999   arg2 = (Dali::HoverEvent *)jarg2;
65000   if (!arg2) {
65001     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
65002     return 0;
65003   }
65004   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65005   if (!darg) {
65006     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65007     return 0;
65008   }
65009   {
65010     try {
65011       result = (bool)(darg)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
65012     } catch (std::out_of_range& e) {
65013       {
65014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65015       };
65016     } catch (std::exception& e) {
65017       {
65018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65019       };
65020     } catch (Dali::DaliException e) {
65021       {
65022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65023       };
65024     } catch (...) {
65025       {
65026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65027       };
65028     }
65029   }
65030
65031   jresult = result;
65032   return jresult;
65033 }
65034
65035
65036 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
65037   unsigned int jresult ;
65038   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65039   Dali::HoverEvent *arg2 = 0 ;
65040   SwigDirector_ViewImpl *darg = 0;
65041   bool result;
65042
65043   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65044   arg2 = (Dali::HoverEvent *)jarg2;
65045   if (!arg2) {
65046     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
65047     return 0;
65048   }
65049   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65050   if (!darg) {
65051     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65052     return 0;
65053   }
65054   {
65055     try {
65056       result = (bool)(darg)->OnHoverEventSwigPublic((Dali::HoverEvent const &)*arg2);
65057     } catch (std::out_of_range& e) {
65058       {
65059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65060       };
65061     } catch (std::exception& e) {
65062       {
65063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65064       };
65065     } catch (Dali::DaliException e) {
65066       {
65067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65068       };
65069     } catch (...) {
65070       {
65071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65072       };
65073     }
65074   }
65075
65076   jresult = result;
65077   return jresult;
65078 }
65079
65080
65081 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEvent(void * jarg1, void * jarg2) {
65082   unsigned int jresult ;
65083   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65084   Dali::KeyEvent *arg2 = 0 ;
65085   SwigDirector_ViewImpl *darg = 0;
65086   bool result;
65087
65088   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65089   arg2 = (Dali::KeyEvent *)jarg2;
65090   if (!arg2) {
65091     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
65092     return 0;
65093   }
65094   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65095   if (!darg) {
65096     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65097     return 0;
65098   }
65099   {
65100     try {
65101       result = (bool)(darg)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
65102     } catch (std::out_of_range& e) {
65103       {
65104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65105       };
65106     } catch (std::exception& e) {
65107       {
65108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65109       };
65110     } catch (Dali::DaliException e) {
65111       {
65112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65113       };
65114     } catch (...) {
65115       {
65116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65117       };
65118     }
65119   }
65120
65121   jresult = result;
65122   return jresult;
65123 }
65124
65125
65126 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
65127   unsigned int jresult ;
65128   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65129   Dali::KeyEvent *arg2 = 0 ;
65130   SwigDirector_ViewImpl *darg = 0;
65131   bool result;
65132
65133   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65134   arg2 = (Dali::KeyEvent *)jarg2;
65135   if (!arg2) {
65136     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
65137     return 0;
65138   }
65139   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65140   if (!darg) {
65141     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65142     return 0;
65143   }
65144   {
65145     try {
65146       result = (bool)(darg)->OnKeyEventSwigPublic((Dali::KeyEvent const &)*arg2);
65147     } catch (std::out_of_range& e) {
65148       {
65149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65150       };
65151     } catch (std::exception& e) {
65152       {
65153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65154       };
65155     } catch (Dali::DaliException e) {
65156       {
65157         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65158       };
65159     } catch (...) {
65160       {
65161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65162       };
65163     }
65164   }
65165
65166   jresult = result;
65167   return jresult;
65168 }
65169
65170
65171 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEvent(void * jarg1, void * jarg2) {
65172   unsigned int jresult ;
65173   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65174   Dali::WheelEvent *arg2 = 0 ;
65175   SwigDirector_ViewImpl *darg = 0;
65176   bool result;
65177
65178   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65179   arg2 = (Dali::WheelEvent *)jarg2;
65180   if (!arg2) {
65181     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
65182     return 0;
65183   }
65184   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65185   if (!darg) {
65186     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65187     return 0;
65188   }
65189   {
65190     try {
65191       result = (bool)(darg)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
65192     } catch (std::out_of_range& e) {
65193       {
65194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65195       };
65196     } catch (std::exception& e) {
65197       {
65198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65199       };
65200     } catch (Dali::DaliException e) {
65201       {
65202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65203       };
65204     } catch (...) {
65205       {
65206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65207       };
65208     }
65209   }
65210
65211   jresult = result;
65212   return jresult;
65213 }
65214
65215
65216 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
65217   unsigned int jresult ;
65218   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65219   Dali::WheelEvent *arg2 = 0 ;
65220   SwigDirector_ViewImpl *darg = 0;
65221   bool result;
65222
65223   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65224   arg2 = (Dali::WheelEvent *)jarg2;
65225   if (!arg2) {
65226     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
65227     return 0;
65228   }
65229   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65230   if (!darg) {
65231     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65232     return 0;
65233   }
65234   {
65235     try {
65236       result = (bool)(darg)->OnWheelEventSwigPublic((Dali::WheelEvent const &)*arg2);
65237     } catch (std::out_of_range& e) {
65238       {
65239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65240       };
65241     } catch (std::exception& e) {
65242       {
65243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65244       };
65245     } catch (Dali::DaliException e) {
65246       {
65247         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65248       };
65249     } catch (...) {
65250       {
65251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65252       };
65253     }
65254   }
65255
65256   jresult = result;
65257   return jresult;
65258 }
65259
65260
65261 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
65262   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65263   Dali::Vector2 *arg2 = 0 ;
65264   Dali::RelayoutContainer *arg3 = 0 ;
65265   SwigDirector_ViewImpl *darg = 0;
65266
65267   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65268   arg2 = (Dali::Vector2 *)jarg2;
65269   if (!arg2) {
65270     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
65271     return ;
65272   }
65273   arg3 = (Dali::RelayoutContainer *)jarg3;
65274   if (!arg3) {
65275     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
65276     return ;
65277   }
65278   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65279   if (!darg) {
65280     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65281     return;
65282   }
65283   {
65284     try {
65285       (darg)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
65286     } catch (std::out_of_range& e) {
65287       {
65288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65289       };
65290     } catch (std::exception& e) {
65291       {
65292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65293       };
65294     } catch (Dali::DaliException e) {
65295       {
65296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65297       };
65298     } catch (...) {
65299       {
65300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65301       };
65302     }
65303   }
65304
65305 }
65306
65307
65308 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayoutSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
65309   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65310   Dali::Vector2 *arg2 = 0 ;
65311   Dali::RelayoutContainer *arg3 = 0 ;
65312   SwigDirector_ViewImpl *darg = 0;
65313
65314   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65315   arg2 = (Dali::Vector2 *)jarg2;
65316   if (!arg2) {
65317     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
65318     return ;
65319   }
65320   arg3 = (Dali::RelayoutContainer *)jarg3;
65321   if (!arg3) {
65322     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
65323     return ;
65324   }
65325   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65326   if (!darg) {
65327     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65328     return;
65329   }
65330   {
65331     try {
65332       (darg)->OnRelayoutSwigPublic((Dali::Vector2 const &)*arg2,*arg3);
65333     } catch (std::out_of_range& e) {
65334       {
65335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65336       };
65337     } catch (std::exception& e) {
65338       {
65339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65340       };
65341     } catch (Dali::DaliException e) {
65342       {
65343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65344       };
65345     } catch (...) {
65346       {
65347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65348       };
65349     }
65350   }
65351
65352 }
65353
65354
65355 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
65356   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65357   Dali::ResizePolicy::Type arg2 ;
65358   Dali::Dimension::Type arg3 ;
65359   SwigDirector_ViewImpl *darg = 0;
65360
65361   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65362   arg2 = (Dali::ResizePolicy::Type)jarg2;
65363   arg3 = (Dali::Dimension::Type)jarg3;
65364   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65365   if (!darg) {
65366     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65367     return;
65368   }
65369   {
65370     try {
65371       (darg)->OnSetResizePolicy(arg2,arg3);
65372     } catch (std::out_of_range& e) {
65373       {
65374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65375       };
65376     } catch (std::exception& e) {
65377       {
65378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65379       };
65380     } catch (Dali::DaliException e) {
65381       {
65382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65383       };
65384     } catch (...) {
65385       {
65386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65387       };
65388     }
65389   }
65390
65391 }
65392
65393
65394 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicySwigExplicitViewImpl(void * jarg1, int jarg2, int jarg3) {
65395   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65396   Dali::ResizePolicy::Type arg2 ;
65397   Dali::Dimension::Type arg3 ;
65398   SwigDirector_ViewImpl *darg = 0;
65399
65400   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65401   arg2 = (Dali::ResizePolicy::Type)jarg2;
65402   arg3 = (Dali::Dimension::Type)jarg3;
65403   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65404   if (!darg) {
65405     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65406     return;
65407   }
65408   {
65409     try {
65410       (darg)->OnSetResizePolicySwigPublic(arg2,arg3);
65411     } catch (std::out_of_range& e) {
65412       {
65413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65414       };
65415     } catch (std::exception& e) {
65416       {
65417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65418       };
65419     } catch (Dali::DaliException e) {
65420       {
65421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65422       };
65423     } catch (...) {
65424       {
65425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65426       };
65427     }
65428   }
65429
65430 }
65431
65432
65433 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSize(void * jarg1) {
65434   void * jresult ;
65435   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65436   SwigDirector_ViewImpl *darg = 0;
65437   Dali::Vector3 result;
65438
65439   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65440   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65441   if (!darg) {
65442     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65443     return 0;
65444   }
65445   {
65446     try {
65447       result = (darg)->GetNaturalSize();
65448     } catch (std::out_of_range& e) {
65449       {
65450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65451       };
65452     } catch (std::exception& e) {
65453       {
65454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65455       };
65456     } catch (Dali::DaliException e) {
65457       {
65458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65459       };
65460     } catch (...) {
65461       {
65462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65463       };
65464     }
65465   }
65466
65467   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
65468   return jresult;
65469 }
65470
65471
65472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSizeSwigExplicitViewImpl(void * jarg1) {
65473   void * jresult ;
65474   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65475   SwigDirector_ViewImpl *darg = 0;
65476   Dali::Vector3 result;
65477
65478   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65479   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65480   if (!darg) {
65481     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65482     return 0;
65483   }
65484   {
65485     try {
65486       result = (darg)->GetNaturalSizeSwigPublic();
65487     } catch (std::out_of_range& e) {
65488       {
65489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65490       };
65491     } catch (std::exception& e) {
65492       {
65493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65494       };
65495     } catch (Dali::DaliException e) {
65496       {
65497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65498       };
65499     } catch (...) {
65500       {
65501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65502       };
65503     }
65504   }
65505
65506   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
65507   return jresult;
65508 }
65509
65510
65511 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
65512   float jresult ;
65513   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65514   Dali::Actor *arg2 = 0 ;
65515   Dali::Dimension::Type arg3 ;
65516   SwigDirector_ViewImpl *darg = 0;
65517   float result;
65518
65519   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65520   arg2 = (Dali::Actor *)jarg2;
65521   if (!arg2) {
65522     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
65523     return 0;
65524   }
65525   arg3 = (Dali::Dimension::Type)jarg3;
65526   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65527   if (!darg) {
65528     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65529     return 0;
65530   }
65531   {
65532     try {
65533       result = (float)(darg)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
65534     } catch (std::out_of_range& e) {
65535       {
65536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65537       };
65538     } catch (std::exception& e) {
65539       {
65540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65541       };
65542     } catch (Dali::DaliException e) {
65543       {
65544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65545       };
65546     } catch (...) {
65547       {
65548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65549       };
65550     }
65551   }
65552
65553   jresult = result;
65554   return jresult;
65555 }
65556
65557
65558 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSizeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
65559   float jresult ;
65560   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65561   Dali::Actor *arg2 = 0 ;
65562   Dali::Dimension::Type arg3 ;
65563   SwigDirector_ViewImpl *darg = 0;
65564   float result;
65565
65566   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65567   arg2 = (Dali::Actor *)jarg2;
65568   if (!arg2) {
65569     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
65570     return 0;
65571   }
65572   arg3 = (Dali::Dimension::Type)jarg3;
65573   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65574   if (!darg) {
65575     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65576     return 0;
65577   }
65578   {
65579     try {
65580       result = (float)(darg)->CalculateChildSizeSwigPublic((Dali::Actor const &)*arg2,arg3);
65581     } catch (std::out_of_range& e) {
65582       {
65583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65584       };
65585     } catch (std::exception& e) {
65586       {
65587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65588       };
65589     } catch (Dali::DaliException e) {
65590       {
65591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65592       };
65593     } catch (...) {
65594       {
65595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65596       };
65597     }
65598   }
65599
65600   jresult = result;
65601   return jresult;
65602 }
65603
65604
65605 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidth(void * jarg1, float jarg2) {
65606   float jresult ;
65607   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65608   float arg2 ;
65609   SwigDirector_ViewImpl *darg = 0;
65610   float result;
65611
65612   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65613   arg2 = (float)jarg2;
65614   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65615   if (!darg) {
65616     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65617     return 0;
65618   }
65619   {
65620     try {
65621       result = (float)(darg)->GetHeightForWidth(arg2);
65622     } catch (std::out_of_range& e) {
65623       {
65624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65625       };
65626     } catch (std::exception& e) {
65627       {
65628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65629       };
65630     } catch (Dali::DaliException e) {
65631       {
65632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65633       };
65634     } catch (...) {
65635       {
65636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65637       };
65638     }
65639   }
65640
65641   jresult = result;
65642   return jresult;
65643 }
65644
65645
65646 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidthSwigExplicitViewImpl(void * jarg1, float jarg2) {
65647   float jresult ;
65648   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65649   float arg2 ;
65650   SwigDirector_ViewImpl *darg = 0;
65651   float result;
65652
65653   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65654   arg2 = (float)jarg2;
65655   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65656   if (!darg) {
65657     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65658     return 0;
65659   }
65660   {
65661     try {
65662       result = (float)(darg)->GetHeightForWidthSwigPublic(arg2);
65663     } catch (std::out_of_range& e) {
65664       {
65665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65666       };
65667     } catch (std::exception& e) {
65668       {
65669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65670       };
65671     } catch (Dali::DaliException e) {
65672       {
65673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65674       };
65675     } catch (...) {
65676       {
65677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65678       };
65679     }
65680   }
65681
65682   jresult = result;
65683   return jresult;
65684 }
65685
65686
65687 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeight(void * jarg1, float jarg2) {
65688   float jresult ;
65689   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65690   float arg2 ;
65691   SwigDirector_ViewImpl *darg = 0;
65692   float result;
65693
65694   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65695   arg2 = (float)jarg2;
65696   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65697   if (!darg) {
65698     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65699     return 0;
65700   }
65701   {
65702     try {
65703       result = (float)(darg)->GetWidthForHeight(arg2);
65704     } catch (std::out_of_range& e) {
65705       {
65706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65707       };
65708     } catch (std::exception& e) {
65709       {
65710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65711       };
65712     } catch (Dali::DaliException e) {
65713       {
65714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65715       };
65716     } catch (...) {
65717       {
65718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65719       };
65720     }
65721   }
65722
65723   jresult = result;
65724   return jresult;
65725 }
65726
65727
65728 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeightSwigExplicitViewImpl(void * jarg1, float jarg2) {
65729   float jresult ;
65730   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65731   float arg2 ;
65732   SwigDirector_ViewImpl *darg = 0;
65733   float result;
65734
65735   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65736   arg2 = (float)jarg2;
65737   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65738   if (!darg) {
65739     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65740     return 0;
65741   }
65742   {
65743     try {
65744       result = (float)(darg)->GetWidthForHeightSwigPublic(arg2);
65745     } catch (std::out_of_range& e) {
65746       {
65747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65748       };
65749     } catch (std::exception& e) {
65750       {
65751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65752       };
65753     } catch (Dali::DaliException e) {
65754       {
65755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65756       };
65757     } catch (...) {
65758       {
65759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65760       };
65761     }
65762   }
65763
65764   jresult = result;
65765   return jresult;
65766 }
65767
65768
65769 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
65770   unsigned int jresult ;
65771   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65772   Dali::Dimension::Type arg2 ;
65773   SwigDirector_ViewImpl *darg = 0;
65774   bool result;
65775
65776   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65777   arg2 = (Dali::Dimension::Type)jarg2;
65778   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65779   if (!darg) {
65780     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65781     return 0;
65782   }
65783   {
65784     try {
65785       result = (bool)(darg)->RelayoutDependentOnChildren(arg2);
65786     } catch (std::out_of_range& e) {
65787       {
65788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65789       };
65790     } catch (std::exception& e) {
65791       {
65792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65793       };
65794     } catch (Dali::DaliException e) {
65795       {
65796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65797       };
65798     } catch (...) {
65799       {
65800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65801       };
65802     }
65803   }
65804
65805   jresult = result;
65806   return jresult;
65807 }
65808
65809
65810 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_0(void * jarg1, int jarg2) {
65811   unsigned int jresult ;
65812   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65813   Dali::Dimension::Type arg2 ;
65814   SwigDirector_ViewImpl *darg = 0;
65815   bool result;
65816
65817   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65818   arg2 = (Dali::Dimension::Type)jarg2;
65819   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65820   if (!darg) {
65821     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65822     return 0;
65823   }
65824   {
65825     try {
65826       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic(arg2);
65827     } catch (std::out_of_range& e) {
65828       {
65829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65830       };
65831     } catch (std::exception& e) {
65832       {
65833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65834       };
65835     } catch (Dali::DaliException e) {
65836       {
65837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65838       };
65839     } catch (...) {
65840       {
65841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65842       };
65843     }
65844   }
65845
65846   jresult = result;
65847   return jresult;
65848 }
65849
65850
65851 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
65852   unsigned int jresult ;
65853   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65854   SwigDirector_ViewImpl *darg = 0;
65855   bool result;
65856
65857   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65858   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65859   if (!darg) {
65860     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65861     return 0;
65862   }
65863   {
65864     try {
65865       result = (bool)(darg)->RelayoutDependentOnChildren();
65866     } catch (std::out_of_range& e) {
65867       {
65868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65869       };
65870     } catch (std::exception& e) {
65871       {
65872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65873       };
65874     } catch (Dali::DaliException e) {
65875       {
65876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65877       };
65878     } catch (...) {
65879       {
65880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65881       };
65882     }
65883   }
65884
65885   jresult = result;
65886   return jresult;
65887 }
65888
65889
65890 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_1(void * jarg1) {
65891   unsigned int jresult ;
65892   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65893   SwigDirector_ViewImpl *darg = 0;
65894   bool result;
65895
65896   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65897   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65898   if (!darg) {
65899     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65900     return 0;
65901   }
65902   {
65903     try {
65904       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic();
65905     } catch (std::out_of_range& e) {
65906       {
65907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65908       };
65909     } catch (std::exception& e) {
65910       {
65911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65912       };
65913     } catch (Dali::DaliException e) {
65914       {
65915         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65916       };
65917     } catch (...) {
65918       {
65919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65920       };
65921     }
65922   }
65923
65924   jresult = result;
65925   return jresult;
65926 }
65927
65928
65929 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
65930   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65931   Dali::Dimension::Type arg2 ;
65932   SwigDirector_ViewImpl *darg = 0;
65933
65934   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65935   arg2 = (Dali::Dimension::Type)jarg2;
65936   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65937   if (!darg) {
65938     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65939     return;
65940   }
65941   {
65942     try {
65943       (darg)->OnCalculateRelayoutSize(arg2);
65944     } catch (std::out_of_range& e) {
65945       {
65946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65947       };
65948     } catch (std::exception& e) {
65949       {
65950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65951       };
65952     } catch (Dali::DaliException e) {
65953       {
65954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65955       };
65956     } catch (...) {
65957       {
65958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65959       };
65960     }
65961   }
65962
65963 }
65964
65965
65966 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSizeSwigExplicitViewImpl(void * jarg1, int jarg2) {
65967   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65968   Dali::Dimension::Type arg2 ;
65969   SwigDirector_ViewImpl *darg = 0;
65970
65971   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65972   arg2 = (Dali::Dimension::Type)jarg2;
65973   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65974   if (!darg) {
65975     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65976     return;
65977   }
65978   {
65979     try {
65980       (darg)->OnCalculateRelayoutSizeSwigPublic(arg2);
65981     } catch (std::out_of_range& e) {
65982       {
65983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65984       };
65985     } catch (std::exception& e) {
65986       {
65987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65988       };
65989     } catch (Dali::DaliException e) {
65990       {
65991         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65992       };
65993     } catch (...) {
65994       {
65995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65996       };
65997     }
65998   }
65999
66000 }
66001
66002
66003 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
66004   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66005   float arg2 ;
66006   Dali::Dimension::Type arg3 ;
66007   SwigDirector_ViewImpl *darg = 0;
66008
66009   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66010   arg2 = (float)jarg2;
66011   arg3 = (Dali::Dimension::Type)jarg3;
66012   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
66013   if (!darg) {
66014     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
66015     return;
66016   }
66017   {
66018     try {
66019       (darg)->OnLayoutNegotiated(arg2,arg3);
66020     } catch (std::out_of_range& e) {
66021       {
66022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66023       };
66024     } catch (std::exception& e) {
66025       {
66026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66027       };
66028     } catch (Dali::DaliException e) {
66029       {
66030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66031       };
66032     } catch (...) {
66033       {
66034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66035       };
66036     }
66037   }
66038
66039 }
66040
66041
66042 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiatedSwigExplicitViewImpl(void * jarg1, float jarg2, int jarg3) {
66043   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66044   float arg2 ;
66045   Dali::Dimension::Type arg3 ;
66046   SwigDirector_ViewImpl *darg = 0;
66047
66048   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66049   arg2 = (float)jarg2;
66050   arg3 = (Dali::Dimension::Type)jarg3;
66051   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
66052   if (!darg) {
66053     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
66054     return;
66055   }
66056   {
66057     try {
66058       (darg)->OnLayoutNegotiatedSwigPublic(arg2,arg3);
66059     } catch (std::out_of_range& e) {
66060       {
66061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66062       };
66063     } catch (std::exception& e) {
66064       {
66065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66066       };
66067     } catch (Dali::DaliException e) {
66068       {
66069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66070       };
66071     } catch (...) {
66072       {
66073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66074       };
66075     }
66076   }
66077
66078 }
66079
66080
66081 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitialize(void * jarg1) {
66082   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66083
66084   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66085   {
66086     try {
66087       (arg1)->OnInitialize();
66088     } catch (std::out_of_range& e) {
66089       {
66090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66091       };
66092     } catch (std::exception& e) {
66093       {
66094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66095       };
66096     } catch (Dali::DaliException e) {
66097       {
66098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66099       };
66100     } catch (...) {
66101       {
66102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66103       };
66104     }
66105   }
66106
66107 }
66108
66109
66110 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitializeSwigExplicitViewImpl(void * jarg1) {
66111   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66112
66113   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66114   {
66115     try {
66116       (arg1)->Dali::Toolkit::Internal::Control::OnInitialize();
66117     } catch (std::out_of_range& e) {
66118       {
66119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66120       };
66121     } catch (std::exception& e) {
66122       {
66123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66124       };
66125     } catch (Dali::DaliException e) {
66126       {
66127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66128       };
66129     } catch (...) {
66130       {
66131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66132       };
66133     }
66134   }
66135
66136 }
66137
66138
66139 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAdd(void * jarg1, void * jarg2) {
66140   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66141   Dali::Actor *arg2 = 0 ;
66142
66143   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66144   arg2 = (Dali::Actor *)jarg2;
66145   if (!arg2) {
66146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
66147     return ;
66148   }
66149   {
66150     try {
66151       (arg1)->OnControlChildAdd(*arg2);
66152     } catch (std::out_of_range& e) {
66153       {
66154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66155       };
66156     } catch (std::exception& e) {
66157       {
66158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66159       };
66160     } catch (Dali::DaliException e) {
66161       {
66162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66163       };
66164     } catch (...) {
66165       {
66166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66167       };
66168     }
66169   }
66170
66171 }
66172
66173
66174 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66175   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66176   Dali::Actor *arg2 = 0 ;
66177
66178   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66179   arg2 = (Dali::Actor *)jarg2;
66180   if (!arg2) {
66181     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
66182     return ;
66183   }
66184   {
66185     try {
66186       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildAdd(*arg2);
66187     } catch (std::out_of_range& e) {
66188       {
66189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66190       };
66191     } catch (std::exception& e) {
66192       {
66193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66194       };
66195     } catch (Dali::DaliException e) {
66196       {
66197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66198       };
66199     } catch (...) {
66200       {
66201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66202       };
66203     }
66204   }
66205
66206 }
66207
66208
66209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemove(void * jarg1, void * jarg2) {
66210   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66211   Dali::Actor *arg2 = 0 ;
66212
66213   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66214   arg2 = (Dali::Actor *)jarg2;
66215   if (!arg2) {
66216     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
66217     return ;
66218   }
66219   {
66220     try {
66221       (arg1)->OnControlChildRemove(*arg2);
66222     } catch (std::out_of_range& e) {
66223       {
66224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66225       };
66226     } catch (std::exception& e) {
66227       {
66228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66229       };
66230     } catch (Dali::DaliException e) {
66231       {
66232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66233       };
66234     } catch (...) {
66235       {
66236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66237       };
66238     }
66239   }
66240
66241 }
66242
66243
66244 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66245   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66246   Dali::Actor *arg2 = 0 ;
66247
66248   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66249   arg2 = (Dali::Actor *)jarg2;
66250   if (!arg2) {
66251     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
66252     return ;
66253   }
66254   {
66255     try {
66256       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildRemove(*arg2);
66257     } catch (std::out_of_range& e) {
66258       {
66259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66260       };
66261     } catch (std::exception& e) {
66262       {
66263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66264       };
66265     } catch (Dali::DaliException e) {
66266       {
66267         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66268       };
66269     } catch (...) {
66270       {
66271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66272       };
66273     }
66274   }
66275
66276 }
66277
66278
66279 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChange(void * jarg1, void * jarg2, int jarg3) {
66280   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66281   Dali::Toolkit::StyleManager arg2 ;
66282   Dali::StyleChange::Type arg3 ;
66283   Dali::Toolkit::StyleManager *argp2 ;
66284
66285   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66286   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
66287   if (!argp2) {
66288     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
66289     return ;
66290   }
66291   arg2 = *argp2;
66292   arg3 = (Dali::StyleChange::Type)jarg3;
66293   {
66294     try {
66295       (arg1)->OnStyleChange(arg2,arg3);
66296     } catch (std::out_of_range& e) {
66297       {
66298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66299       };
66300     } catch (std::exception& e) {
66301       {
66302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66303       };
66304     } catch (Dali::DaliException e) {
66305       {
66306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66307       };
66308     } catch (...) {
66309       {
66310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66311       };
66312     }
66313   }
66314
66315 }
66316
66317
66318 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChangeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
66319   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66320   Dali::Toolkit::StyleManager arg2 ;
66321   Dali::StyleChange::Type arg3 ;
66322   Dali::Toolkit::StyleManager *argp2 ;
66323
66324   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66325   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
66326   if (!argp2) {
66327     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
66328     return ;
66329   }
66330   arg2 = *argp2;
66331   arg3 = (Dali::StyleChange::Type)jarg3;
66332   {
66333     try {
66334       (arg1)->Dali::Toolkit::Internal::Control::OnStyleChange(arg2,arg3);
66335     } catch (std::out_of_range& e) {
66336       {
66337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66338       };
66339     } catch (std::exception& e) {
66340       {
66341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66342       };
66343     } catch (Dali::DaliException e) {
66344       {
66345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66346       };
66347     } catch (...) {
66348       {
66349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66350       };
66351     }
66352   }
66353
66354 }
66355
66356
66357 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivated(void * jarg1) {
66358   unsigned int jresult ;
66359   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66360   bool result;
66361
66362   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66363   {
66364     try {
66365       result = (bool)(arg1)->OnAccessibilityActivated();
66366     } catch (std::out_of_range& e) {
66367       {
66368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66369       };
66370     } catch (std::exception& e) {
66371       {
66372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66373       };
66374     } catch (Dali::DaliException e) {
66375       {
66376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66377       };
66378     } catch (...) {
66379       {
66380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66381       };
66382     }
66383   }
66384
66385   jresult = result;
66386   return jresult;
66387 }
66388
66389
66390 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivatedSwigExplicitViewImpl(void * jarg1) {
66391   unsigned int jresult ;
66392   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66393   bool result;
66394
66395   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66396   {
66397     try {
66398       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
66399     } catch (std::out_of_range& e) {
66400       {
66401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66402       };
66403     } catch (std::exception& e) {
66404       {
66405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66406       };
66407     } catch (Dali::DaliException e) {
66408       {
66409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66410       };
66411     } catch (...) {
66412       {
66413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66414       };
66415     }
66416   }
66417
66418   jresult = result;
66419   return jresult;
66420 }
66421
66422
66423 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPan(void * jarg1, void * jarg2) {
66424   unsigned int jresult ;
66425   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66426   Dali::PanGesture arg2 ;
66427   Dali::PanGesture *argp2 ;
66428   bool result;
66429
66430   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66431   argp2 = (Dali::PanGesture *)jarg2;
66432   if (!argp2) {
66433     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
66434     return 0;
66435   }
66436   arg2 = *argp2;
66437   {
66438     try {
66439       result = (bool)(arg1)->OnAccessibilityPan(arg2);
66440     } catch (std::out_of_range& e) {
66441       {
66442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66443       };
66444     } catch (std::exception& e) {
66445       {
66446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66447       };
66448     } catch (Dali::DaliException e) {
66449       {
66450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66451       };
66452     } catch (...) {
66453       {
66454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66455       };
66456     }
66457   }
66458
66459   jresult = result;
66460   return jresult;
66461 }
66462
66463
66464 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66465   unsigned int jresult ;
66466   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66467   Dali::PanGesture arg2 ;
66468   Dali::PanGesture *argp2 ;
66469   bool result;
66470
66471   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66472   argp2 = (Dali::PanGesture *)jarg2;
66473   if (!argp2) {
66474     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
66475     return 0;
66476   }
66477   arg2 = *argp2;
66478   {
66479     try {
66480       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityPan(arg2);
66481     } catch (std::out_of_range& e) {
66482       {
66483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66484       };
66485     } catch (std::exception& e) {
66486       {
66487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66488       };
66489     } catch (Dali::DaliException e) {
66490       {
66491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66492       };
66493     } catch (...) {
66494       {
66495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66496       };
66497     }
66498   }
66499
66500   jresult = result;
66501   return jresult;
66502 }
66503
66504
66505 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouch(void * jarg1, void * jarg2) {
66506   unsigned int jresult ;
66507   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66508   Dali::TouchEvent *arg2 = 0 ;
66509   bool result;
66510
66511   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66512   arg2 = (Dali::TouchEvent *)jarg2;
66513   if (!arg2) {
66514     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
66515     return 0;
66516   }
66517   {
66518     try {
66519       result = (bool)(arg1)->OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
66520     } catch (std::out_of_range& e) {
66521       {
66522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66523       };
66524     } catch (std::exception& e) {
66525       {
66526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66527       };
66528     } catch (Dali::DaliException e) {
66529       {
66530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66531       };
66532     } catch (...) {
66533       {
66534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66535       };
66536     }
66537   }
66538
66539   jresult = result;
66540   return jresult;
66541 }
66542
66543
66544 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66545   unsigned int jresult ;
66546   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66547   Dali::TouchEvent *arg2 = 0 ;
66548   bool result;
66549
66550   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66551   arg2 = (Dali::TouchEvent *)jarg2;
66552   if (!arg2) {
66553     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
66554     return 0;
66555   }
66556   {
66557     try {
66558       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
66559     } catch (std::out_of_range& e) {
66560       {
66561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66562       };
66563     } catch (std::exception& e) {
66564       {
66565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66566       };
66567     } catch (Dali::DaliException e) {
66568       {
66569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66570       };
66571     } catch (...) {
66572       {
66573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66574       };
66575     }
66576   }
66577
66578   jresult = result;
66579   return jresult;
66580 }
66581
66582
66583 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChange(void * jarg1, unsigned int jarg2) {
66584   unsigned int jresult ;
66585   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66586   bool arg2 ;
66587   bool result;
66588
66589   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66590   arg2 = jarg2 ? true : false;
66591   {
66592     try {
66593       result = (bool)(arg1)->OnAccessibilityValueChange(arg2);
66594     } catch (std::out_of_range& e) {
66595       {
66596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66597       };
66598     } catch (std::exception& e) {
66599       {
66600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66601       };
66602     } catch (Dali::DaliException e) {
66603       {
66604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66605       };
66606     } catch (...) {
66607       {
66608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66609       };
66610     }
66611   }
66612
66613   jresult = result;
66614   return jresult;
66615 }
66616
66617
66618 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChangeSwigExplicitViewImpl(void * jarg1, unsigned int jarg2) {
66619   unsigned int jresult ;
66620   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66621   bool arg2 ;
66622   bool result;
66623
66624   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66625   arg2 = jarg2 ? true : false;
66626   {
66627     try {
66628       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(arg2);
66629     } catch (std::out_of_range& e) {
66630       {
66631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66632       };
66633     } catch (std::exception& e) {
66634       {
66635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66636       };
66637     } catch (Dali::DaliException e) {
66638       {
66639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66640       };
66641     } catch (...) {
66642       {
66643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66644       };
66645     }
66646   }
66647
66648   jresult = result;
66649   return jresult;
66650 }
66651
66652
66653 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoom(void * jarg1) {
66654   unsigned int jresult ;
66655   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66656   bool result;
66657
66658   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66659   {
66660     try {
66661       result = (bool)(arg1)->OnAccessibilityZoom();
66662     } catch (std::out_of_range& e) {
66663       {
66664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66665       };
66666     } catch (std::exception& e) {
66667       {
66668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66669       };
66670     } catch (Dali::DaliException e) {
66671       {
66672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66673       };
66674     } catch (...) {
66675       {
66676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66677       };
66678     }
66679   }
66680
66681   jresult = result;
66682   return jresult;
66683 }
66684
66685
66686 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoomSwigExplicitViewImpl(void * jarg1) {
66687   unsigned int jresult ;
66688   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66689   bool result;
66690
66691   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66692   {
66693     try {
66694       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
66695     } catch (std::out_of_range& e) {
66696       {
66697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66698       };
66699     } catch (std::exception& e) {
66700       {
66701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66702       };
66703     } catch (Dali::DaliException e) {
66704       {
66705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66706       };
66707     } catch (...) {
66708       {
66709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66710       };
66711     }
66712   }
66713
66714   jresult = result;
66715   return jresult;
66716 }
66717
66718
66719 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGained(void * jarg1) {
66720   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66721
66722   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66723   {
66724     try {
66725       (arg1)->OnKeyInputFocusGained();
66726     } catch (std::out_of_range& e) {
66727       {
66728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66729       };
66730     } catch (std::exception& e) {
66731       {
66732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66733       };
66734     } catch (Dali::DaliException e) {
66735       {
66736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66737       };
66738     } catch (...) {
66739       {
66740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66741       };
66742     }
66743   }
66744
66745 }
66746
66747
66748 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGainedSwigExplicitViewImpl(void * jarg1) {
66749   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66750
66751   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66752   {
66753     try {
66754       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
66755     } catch (std::out_of_range& e) {
66756       {
66757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66758       };
66759     } catch (std::exception& e) {
66760       {
66761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66762       };
66763     } catch (Dali::DaliException e) {
66764       {
66765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66766       };
66767     } catch (...) {
66768       {
66769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66770       };
66771     }
66772   }
66773
66774 }
66775
66776
66777 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLost(void * jarg1) {
66778   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66779
66780   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66781   {
66782     try {
66783       (arg1)->OnKeyInputFocusLost();
66784     } catch (std::out_of_range& e) {
66785       {
66786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66787       };
66788     } catch (std::exception& e) {
66789       {
66790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66791       };
66792     } catch (Dali::DaliException e) {
66793       {
66794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66795       };
66796     } catch (...) {
66797       {
66798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66799       };
66800     }
66801   }
66802
66803 }
66804
66805
66806 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLostSwigExplicitViewImpl(void * jarg1) {
66807   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66808
66809   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66810   {
66811     try {
66812       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
66813     } catch (std::out_of_range& e) {
66814       {
66815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66816       };
66817     } catch (std::exception& e) {
66818       {
66819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66820       };
66821     } catch (Dali::DaliException e) {
66822       {
66823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66824       };
66825     } catch (...) {
66826       {
66827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66828       };
66829     }
66830   }
66831
66832 }
66833
66834
66835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActor(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
66836   void * jresult ;
66837   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66838   Dali::Actor arg2 ;
66839   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
66840   bool arg4 ;
66841   Dali::Actor *argp2 ;
66842   Dali::Actor result;
66843
66844   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66845   argp2 = (Dali::Actor *)jarg2;
66846   if (!argp2) {
66847     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66848     return 0;
66849   }
66850   arg2 = *argp2;
66851   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
66852   arg4 = jarg4 ? true : false;
66853   {
66854     try {
66855       result = (arg1)->GetNextKeyboardFocusableActor(arg2,arg3,arg4);
66856     } catch (std::out_of_range& e) {
66857       {
66858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66859       };
66860     } catch (std::exception& e) {
66861       {
66862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66863       };
66864     } catch (Dali::DaliException e) {
66865       {
66866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66867       };
66868     } catch (...) {
66869       {
66870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66871       };
66872     }
66873   }
66874
66875   jresult = new Dali::Actor((const Dali::Actor &)result);
66876   return jresult;
66877 }
66878
66879
66880 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActorSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
66881   void * jresult ;
66882   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66883   Dali::Actor arg2 ;
66884   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
66885   bool arg4 ;
66886   Dali::Actor *argp2 ;
66887   Dali::Actor result;
66888
66889   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66890   argp2 = (Dali::Actor *)jarg2;
66891   if (!argp2) {
66892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66893     return 0;
66894   }
66895   arg2 = *argp2;
66896   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
66897   arg4 = jarg4 ? true : false;
66898   {
66899     try {
66900       result = (arg1)->Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(arg2,arg3,arg4);
66901     } catch (std::out_of_range& e) {
66902       {
66903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66904       };
66905     } catch (std::exception& e) {
66906       {
66907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66908       };
66909     } catch (Dali::DaliException e) {
66910       {
66911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66912       };
66913     } catch (...) {
66914       {
66915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66916       };
66917     }
66918   }
66919
66920   jresult = new Dali::Actor((const Dali::Actor &)result);
66921   return jresult;
66922 }
66923
66924
66925 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommitted(void * jarg1, void * jarg2) {
66926   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66927   Dali::Actor arg2 ;
66928   Dali::Actor *argp2 ;
66929
66930   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66931   argp2 = (Dali::Actor *)jarg2;
66932   if (!argp2) {
66933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66934     return ;
66935   }
66936   arg2 = *argp2;
66937   {
66938     try {
66939       (arg1)->OnKeyboardFocusChangeCommitted(arg2);
66940     } catch (std::out_of_range& e) {
66941       {
66942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66943       };
66944     } catch (std::exception& e) {
66945       {
66946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66947       };
66948     } catch (Dali::DaliException e) {
66949       {
66950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66951       };
66952     } catch (...) {
66953       {
66954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66955       };
66956     }
66957   }
66958
66959 }
66960
66961
66962 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommittedSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66963   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66964   Dali::Actor arg2 ;
66965   Dali::Actor *argp2 ;
66966
66967   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66968   argp2 = (Dali::Actor *)jarg2;
66969   if (!argp2) {
66970     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66971     return ;
66972   }
66973   arg2 = *argp2;
66974   {
66975     try {
66976       (arg1)->Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(arg2);
66977     } catch (std::out_of_range& e) {
66978       {
66979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66980       };
66981     } catch (std::exception& e) {
66982       {
66983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66984       };
66985     } catch (Dali::DaliException e) {
66986       {
66987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66988       };
66989     } catch (...) {
66990       {
66991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66992       };
66993     }
66994   }
66995
66996 }
66997
66998
66999 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnter(void * jarg1) {
67000   unsigned int jresult ;
67001   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67002   bool result;
67003
67004   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67005   {
67006     try {
67007       result = (bool)(arg1)->OnKeyboardEnter();
67008     } catch (std::out_of_range& e) {
67009       {
67010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67011       };
67012     } catch (std::exception& e) {
67013       {
67014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67015       };
67016     } catch (Dali::DaliException e) {
67017       {
67018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67019       };
67020     } catch (...) {
67021       {
67022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67023       };
67024     }
67025   }
67026
67027   jresult = result;
67028   return jresult;
67029 }
67030
67031
67032 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnterSwigExplicitViewImpl(void * jarg1) {
67033   unsigned int jresult ;
67034   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67035   bool result;
67036
67037   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67038   {
67039     try {
67040       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnKeyboardEnter();
67041     } catch (std::out_of_range& e) {
67042       {
67043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67044       };
67045     } catch (std::exception& e) {
67046       {
67047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67048       };
67049     } catch (Dali::DaliException e) {
67050       {
67051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67052       };
67053     } catch (...) {
67054       {
67055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67056       };
67057     }
67058   }
67059
67060   jresult = result;
67061   return jresult;
67062 }
67063
67064
67065 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinch(void * jarg1, void * jarg2) {
67066   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67067   Dali::PinchGesture *arg2 = 0 ;
67068
67069   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67070   arg2 = (Dali::PinchGesture *)jarg2;
67071   if (!arg2) {
67072     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
67073     return ;
67074   }
67075   {
67076     try {
67077       (arg1)->OnPinch((Dali::PinchGesture const &)*arg2);
67078     } catch (std::out_of_range& e) {
67079       {
67080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67081       };
67082     } catch (std::exception& e) {
67083       {
67084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67085       };
67086     } catch (Dali::DaliException e) {
67087       {
67088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67089       };
67090     } catch (...) {
67091       {
67092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67093       };
67094     }
67095   }
67096
67097 }
67098
67099
67100 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
67101   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67102   Dali::PinchGesture *arg2 = 0 ;
67103
67104   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67105   arg2 = (Dali::PinchGesture *)jarg2;
67106   if (!arg2) {
67107     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
67108     return ;
67109   }
67110   {
67111     try {
67112       (arg1)->Dali::Toolkit::Internal::Control::OnPinch((Dali::PinchGesture const &)*arg2);
67113     } catch (std::out_of_range& e) {
67114       {
67115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67116       };
67117     } catch (std::exception& e) {
67118       {
67119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67120       };
67121     } catch (Dali::DaliException e) {
67122       {
67123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67124       };
67125     } catch (...) {
67126       {
67127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67128       };
67129     }
67130   }
67131
67132 }
67133
67134
67135 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPan(void * jarg1, void * jarg2) {
67136   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67137   Dali::PanGesture *arg2 = 0 ;
67138
67139   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67140   arg2 = (Dali::PanGesture *)jarg2;
67141   if (!arg2) {
67142     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
67143     return ;
67144   }
67145   {
67146     try {
67147       (arg1)->OnPan((Dali::PanGesture const &)*arg2);
67148     } catch (std::out_of_range& e) {
67149       {
67150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67151       };
67152     } catch (std::exception& e) {
67153       {
67154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67155       };
67156     } catch (Dali::DaliException e) {
67157       {
67158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67159       };
67160     } catch (...) {
67161       {
67162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67163       };
67164     }
67165   }
67166
67167 }
67168
67169
67170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
67171   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67172   Dali::PanGesture *arg2 = 0 ;
67173
67174   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67175   arg2 = (Dali::PanGesture *)jarg2;
67176   if (!arg2) {
67177     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
67178     return ;
67179   }
67180   {
67181     try {
67182       (arg1)->Dali::Toolkit::Internal::Control::OnPan((Dali::PanGesture const &)*arg2);
67183     } catch (std::out_of_range& e) {
67184       {
67185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67186       };
67187     } catch (std::exception& e) {
67188       {
67189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67190       };
67191     } catch (Dali::DaliException e) {
67192       {
67193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67194       };
67195     } catch (...) {
67196       {
67197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67198       };
67199     }
67200   }
67201
67202 }
67203
67204
67205 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTap(void * jarg1, void * jarg2) {
67206   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67207   Dali::TapGesture *arg2 = 0 ;
67208
67209   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67210   arg2 = (Dali::TapGesture *)jarg2;
67211   if (!arg2) {
67212     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
67213     return ;
67214   }
67215   {
67216     try {
67217       (arg1)->OnTap((Dali::TapGesture const &)*arg2);
67218     } catch (std::out_of_range& e) {
67219       {
67220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67221       };
67222     } catch (std::exception& e) {
67223       {
67224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67225       };
67226     } catch (Dali::DaliException e) {
67227       {
67228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67229       };
67230     } catch (...) {
67231       {
67232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67233       };
67234     }
67235   }
67236
67237 }
67238
67239
67240 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTapSwigExplicitViewImpl(void * jarg1, void * jarg2) {
67241   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67242   Dali::TapGesture *arg2 = 0 ;
67243
67244   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67245   arg2 = (Dali::TapGesture *)jarg2;
67246   if (!arg2) {
67247     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
67248     return ;
67249   }
67250   {
67251     try {
67252       (arg1)->Dali::Toolkit::Internal::Control::OnTap((Dali::TapGesture const &)*arg2);
67253     } catch (std::out_of_range& e) {
67254       {
67255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67256       };
67257     } catch (std::exception& e) {
67258       {
67259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67260       };
67261     } catch (Dali::DaliException e) {
67262       {
67263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67264       };
67265     } catch (...) {
67266       {
67267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67268       };
67269     }
67270   }
67271
67272 }
67273
67274
67275 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPress(void * jarg1, void * jarg2) {
67276   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67277   Dali::LongPressGesture *arg2 = 0 ;
67278
67279   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67280   arg2 = (Dali::LongPressGesture *)jarg2;
67281   if (!arg2) {
67282     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
67283     return ;
67284   }
67285   {
67286     try {
67287       (arg1)->OnLongPress((Dali::LongPressGesture const &)*arg2);
67288     } catch (std::out_of_range& e) {
67289       {
67290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67291       };
67292     } catch (std::exception& e) {
67293       {
67294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67295       };
67296     } catch (Dali::DaliException e) {
67297       {
67298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67299       };
67300     } catch (...) {
67301       {
67302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67303       };
67304     }
67305   }
67306
67307 }
67308
67309
67310 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPressSwigExplicitViewImpl(void * jarg1, void * jarg2) {
67311   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67312   Dali::LongPressGesture *arg2 = 0 ;
67313
67314   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67315   arg2 = (Dali::LongPressGesture *)jarg2;
67316   if (!arg2) {
67317     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
67318     return ;
67319   }
67320   {
67321     try {
67322       (arg1)->Dali::Toolkit::Internal::Control::OnLongPress((Dali::LongPressGesture const &)*arg2);
67323     } catch (std::out_of_range& e) {
67324       {
67325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67326       };
67327     } catch (std::exception& e) {
67328       {
67329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67330       };
67331     } catch (Dali::DaliException e) {
67332       {
67333         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67334       };
67335     } catch (...) {
67336       {
67337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67338       };
67339     }
67340   }
67341
67342 }
67343
67344
67345 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
67346   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67347   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
67348   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
67349
67350   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67351   arg2 = (Dali::SlotObserver *)jarg2;
67352   arg3 = (Dali::CallbackBase *)jarg3;
67353   {
67354     try {
67355       (arg1)->SignalConnected(arg2,arg3);
67356     } catch (std::out_of_range& e) {
67357       {
67358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67359       };
67360     } catch (std::exception& e) {
67361       {
67362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67363       };
67364     } catch (Dali::DaliException e) {
67365       {
67366         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67367       };
67368     } catch (...) {
67369       {
67370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67371       };
67372     }
67373   }
67374
67375 }
67376
67377
67378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
67379   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67380   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
67381   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
67382
67383   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67384   arg2 = (Dali::SlotObserver *)jarg2;
67385   arg3 = (Dali::CallbackBase *)jarg3;
67386   {
67387     try {
67388       (arg1)->Dali::Toolkit::Internal::Control::SignalConnected(arg2,arg3);
67389     } catch (std::out_of_range& e) {
67390       {
67391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67392       };
67393     } catch (std::exception& e) {
67394       {
67395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67396       };
67397     } catch (Dali::DaliException e) {
67398       {
67399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67400       };
67401     } catch (...) {
67402       {
67403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67404       };
67405     }
67406   }
67407
67408 }
67409
67410
67411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
67412   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67413   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
67414   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
67415
67416   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67417   arg2 = (Dali::SlotObserver *)jarg2;
67418   arg3 = (Dali::CallbackBase *)jarg3;
67419   {
67420     try {
67421       (arg1)->SignalDisconnected(arg2,arg3);
67422     } catch (std::out_of_range& e) {
67423       {
67424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67425       };
67426     } catch (std::exception& e) {
67427       {
67428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67429       };
67430     } catch (Dali::DaliException e) {
67431       {
67432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67433       };
67434     } catch (...) {
67435       {
67436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67437       };
67438     }
67439   }
67440
67441 }
67442
67443
67444 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
67445   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67446   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
67447   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
67448
67449   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67450   arg2 = (Dali::SlotObserver *)jarg2;
67451   arg3 = (Dali::CallbackBase *)jarg3;
67452   {
67453     try {
67454       (arg1)->Dali::Toolkit::Internal::Control::SignalDisconnected(arg2,arg3);
67455     } catch (std::out_of_range& e) {
67456       {
67457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67458       };
67459     } catch (std::exception& e) {
67460       {
67461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67462       };
67463     } catch (Dali::DaliException e) {
67464       {
67465         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67466       };
67467     } catch (...) {
67468       {
67469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67470       };
67471     }
67472   }
67473
67474 }
67475
67476
67477 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) {
67478   Dali::Toolkit::Internal::Control *obj = (Dali::Toolkit::Internal::Control *)objarg;
67479   SwigDirector_ViewImpl *director = dynamic_cast<SwigDirector_ViewImpl *>(obj);
67480   if (director) {
67481     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);
67482   }
67483 }
67484
67485
67486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation__SWIG_0(void * jarg1) {
67487   void * jresult ;
67488   Dali::Toolkit::Control *arg1 = 0 ;
67489   Dali::Toolkit::Internal::Control *result = 0 ;
67490
67491   arg1 = (Dali::Toolkit::Control *)jarg1;
67492   if (!arg1) {
67493     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
67494     return 0;
67495   }
67496   {
67497     try {
67498       result = (Dali::Toolkit::Internal::Control *) &Dali::Toolkit::Internal::GetImplementation(*arg1);
67499     } catch (std::out_of_range& e) {
67500       {
67501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67502       };
67503     } catch (std::exception& e) {
67504       {
67505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67506       };
67507     } catch (Dali::DaliException e) {
67508       {
67509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67510       };
67511     } catch (...) {
67512       {
67513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67514       };
67515     }
67516   }
67517
67518   jresult = (void *)result;
67519   return jresult;
67520 }
67521
67522
67523 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_STYLE_NAME_get() {
67524   int jresult ;
67525   int result;
67526
67527   result = (int)Dali::Toolkit::Control::Property::STYLE_NAME;
67528   jresult = (int)result;
67529   return jresult;
67530 }
67531
67532
67533 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_COLOR_get() {
67534   int jresult ;
67535   int result;
67536
67537   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_COLOR;
67538   jresult = (int)result;
67539   return jresult;
67540 }
67541
67542
67543 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_IMAGE_get() {
67544   int jresult ;
67545   int result;
67546
67547   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_IMAGE;
67548   jresult = (int)result;
67549   return jresult;
67550 }
67551
67552
67553 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_KEY_INPUT_FOCUS_get() {
67554   int jresult ;
67555   int result;
67556
67557   result = (int)Dali::Toolkit::Control::Property::KEY_INPUT_FOCUS;
67558   jresult = (int)result;
67559   return jresult;
67560 }
67561
67562
67563 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_get() {
67564   int jresult ;
67565   int result;
67566
67567   result = (int)Dali::Toolkit::Control::Property::BACKGROUND;
67568   jresult = (int)result;
67569   return jresult;
67570 }
67571
67572 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_MARGIN_get() {
67573   int jresult ;
67574   int result;
67575
67576   result = (int)Dali::Toolkit::Control::Property::MARGIN;
67577   jresult = (int)result;
67578   return jresult;
67579 }
67580
67581
67582 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_PADDING_get() {
67583   int jresult ;
67584   int result;
67585
67586   result = (int)Dali::Toolkit::Control::Property::PADDING;
67587   jresult = (int)result;
67588   return jresult;
67589 }
67590
67591 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_Property() {
67592   void * jresult ;
67593   Dali::Toolkit::Control::Property *result = 0 ;
67594
67595   {
67596     try {
67597       result = (Dali::Toolkit::Control::Property *)new Dali::Toolkit::Control::Property();
67598     } catch (std::out_of_range& e) {
67599       {
67600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67601       };
67602     } catch (std::exception& e) {
67603       {
67604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67605       };
67606     } catch (Dali::DaliException e) {
67607       {
67608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67609       };
67610     } catch (...) {
67611       {
67612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67613       };
67614     }
67615   }
67616
67617   jresult = (void *)result;
67618   return jresult;
67619 }
67620
67621
67622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_Property(void * jarg1) {
67623   Dali::Toolkit::Control::Property *arg1 = (Dali::Toolkit::Control::Property *) 0 ;
67624
67625   arg1 = (Dali::Toolkit::Control::Property *)jarg1;
67626   {
67627     try {
67628       delete arg1;
67629     } catch (std::out_of_range& e) {
67630       {
67631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67632       };
67633     } catch (std::exception& e) {
67634       {
67635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67636       };
67637     } catch (Dali::DaliException e) {
67638       {
67639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67640       };
67641     } catch (...) {
67642       {
67643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67644       };
67645     }
67646   }
67647
67648 }
67649
67650
67651 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_KeyboardFocus() {
67652   void * jresult ;
67653   Dali::Toolkit::Control::KeyboardFocus *result = 0 ;
67654
67655   {
67656     try {
67657       result = (Dali::Toolkit::Control::KeyboardFocus *)new Dali::Toolkit::Control::KeyboardFocus();
67658     } catch (std::out_of_range& e) {
67659       {
67660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67661       };
67662     } catch (std::exception& e) {
67663       {
67664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67665       };
67666     } catch (Dali::DaliException e) {
67667       {
67668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67669       };
67670     } catch (...) {
67671       {
67672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67673       };
67674     }
67675   }
67676
67677   jresult = (void *)result;
67678   return jresult;
67679 }
67680
67681
67682 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_KeyboardFocus(void * jarg1) {
67683   Dali::Toolkit::Control::KeyboardFocus *arg1 = (Dali::Toolkit::Control::KeyboardFocus *) 0 ;
67684
67685   arg1 = (Dali::Toolkit::Control::KeyboardFocus *)jarg1;
67686   {
67687     try {
67688       delete arg1;
67689     } catch (std::out_of_range& e) {
67690       {
67691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67692       };
67693     } catch (std::exception& e) {
67694       {
67695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67696       };
67697     } catch (Dali::DaliException e) {
67698       {
67699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67700       };
67701     } catch (...) {
67702       {
67703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67704       };
67705     }
67706   }
67707
67708 }
67709
67710
67711 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_New() {
67712   void * jresult ;
67713   Dali::Toolkit::Control result;
67714
67715   {
67716     try {
67717       result = Dali::Toolkit::Control::New();
67718     } catch (std::out_of_range& e) {
67719       {
67720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67721       };
67722     } catch (std::exception& e) {
67723       {
67724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67725       };
67726     } catch (Dali::DaliException e) {
67727       {
67728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67729       };
67730     } catch (...) {
67731       {
67732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67733       };
67734     }
67735   }
67736
67737   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
67738   return jresult;
67739 }
67740
67741
67742 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_0() {
67743   void * jresult ;
67744   Dali::Toolkit::Control *result = 0 ;
67745
67746   {
67747     try {
67748       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control();
67749     } catch (std::out_of_range& e) {
67750       {
67751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67752       };
67753     } catch (std::exception& e) {
67754       {
67755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67756       };
67757     } catch (Dali::DaliException e) {
67758       {
67759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67760       };
67761     } catch (...) {
67762       {
67763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67764       };
67765     }
67766   }
67767
67768   jresult = (void *)result;
67769   return jresult;
67770 }
67771
67772
67773 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_1(void * jarg1) {
67774   void * jresult ;
67775   Dali::Toolkit::Control *arg1 = 0 ;
67776   Dali::Toolkit::Control *result = 0 ;
67777
67778   arg1 = (Dali::Toolkit::Control *)jarg1;
67779   if (!arg1) {
67780     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
67781     return 0;
67782   }
67783   {
67784     try {
67785       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control((Dali::Toolkit::Control const &)*arg1);
67786     } catch (std::out_of_range& e) {
67787       {
67788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67789       };
67790     } catch (std::exception& e) {
67791       {
67792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67793       };
67794     } catch (Dali::DaliException e) {
67795       {
67796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67797       };
67798     } catch (...) {
67799       {
67800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67801       };
67802     }
67803   }
67804
67805   jresult = (void *)result;
67806   return jresult;
67807 }
67808
67809
67810 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View(void * jarg1) {
67811   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67812
67813   arg1 = (Dali::Toolkit::Control *)jarg1;
67814   {
67815     try {
67816       delete arg1;
67817     } catch (std::out_of_range& e) {
67818       {
67819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67820       };
67821     } catch (std::exception& e) {
67822       {
67823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67824       };
67825     } catch (Dali::DaliException e) {
67826       {
67827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67828       };
67829     } catch (...) {
67830       {
67831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67832       };
67833     }
67834   }
67835
67836 }
67837
67838
67839 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_Assign(void * jarg1, void * jarg2) {
67840   void * jresult ;
67841   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67842   Dali::Toolkit::Control *arg2 = 0 ;
67843   Dali::Toolkit::Control *result = 0 ;
67844
67845   arg1 = (Dali::Toolkit::Control *)jarg1;
67846   arg2 = (Dali::Toolkit::Control *)jarg2;
67847   if (!arg2) {
67848     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
67849     return 0;
67850   }
67851   {
67852     try {
67853       result = (Dali::Toolkit::Control *) &(arg1)->operator =((Dali::Toolkit::Control const &)*arg2);
67854     } catch (std::out_of_range& e) {
67855       {
67856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67857       };
67858     } catch (std::exception& e) {
67859       {
67860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67861       };
67862     } catch (Dali::DaliException e) {
67863       {
67864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67865       };
67866     } catch (...) {
67867       {
67868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67869       };
67870     }
67871   }
67872
67873   jresult = (void *)result;
67874   return jresult;
67875 }
67876
67877
67878 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_DownCast(void * jarg1) {
67879   void * jresult ;
67880   Dali::BaseHandle arg1 ;
67881   Dali::BaseHandle *argp1 ;
67882   Dali::Toolkit::Control result;
67883
67884   argp1 = (Dali::BaseHandle *)jarg1;
67885   if (!argp1) {
67886     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67887     return 0;
67888   }
67889   arg1 = *argp1;
67890   {
67891     try {
67892       result = Dali::Toolkit::Control::DownCast(arg1);
67893     } catch (std::out_of_range& e) {
67894       {
67895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67896       };
67897     } catch (std::exception& e) {
67898       {
67899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67900       };
67901     } catch (Dali::DaliException e) {
67902       {
67903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67904       };
67905     } catch (...) {
67906       {
67907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67908       };
67909     }
67910   }
67911
67912   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
67913   return jresult;
67914 }
67915
67916
67917 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetKeyInputFocus(void * jarg1) {
67918   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67919
67920   arg1 = (Dali::Toolkit::Control *)jarg1;
67921   {
67922     try {
67923       (arg1)->SetKeyInputFocus();
67924     } catch (std::out_of_range& e) {
67925       {
67926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67927       };
67928     } catch (std::exception& e) {
67929       {
67930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67931       };
67932     } catch (Dali::DaliException e) {
67933       {
67934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67935       };
67936     } catch (...) {
67937       {
67938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67939       };
67940     }
67941   }
67942
67943 }
67944
67945
67946 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_View_HasKeyInputFocus(void * jarg1) {
67947   unsigned int jresult ;
67948   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67949   bool result;
67950
67951   arg1 = (Dali::Toolkit::Control *)jarg1;
67952   {
67953     try {
67954       result = (bool)(arg1)->HasKeyInputFocus();
67955     } catch (std::out_of_range& e) {
67956       {
67957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67958       };
67959     } catch (std::exception& e) {
67960       {
67961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67962       };
67963     } catch (Dali::DaliException e) {
67964       {
67965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67966       };
67967     } catch (...) {
67968       {
67969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67970       };
67971     }
67972   }
67973
67974   jresult = result;
67975   return jresult;
67976 }
67977
67978
67979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearKeyInputFocus(void * jarg1) {
67980   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67981
67982   arg1 = (Dali::Toolkit::Control *)jarg1;
67983   {
67984     try {
67985       (arg1)->ClearKeyInputFocus();
67986     } catch (std::out_of_range& e) {
67987       {
67988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67989       };
67990     } catch (std::exception& e) {
67991       {
67992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67993       };
67994     } catch (Dali::DaliException e) {
67995       {
67996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67997       };
67998     } catch (...) {
67999       {
68000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68001       };
68002     }
68003   }
68004
68005 }
68006
68007
68008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPinchGestureDetector(void * jarg1) {
68009   void * jresult ;
68010   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68011   Dali::PinchGestureDetector result;
68012
68013   arg1 = (Dali::Toolkit::Control *)jarg1;
68014   {
68015     try {
68016       result = ((Dali::Toolkit::Control const *)arg1)->GetPinchGestureDetector();
68017     } catch (std::out_of_range& e) {
68018       {
68019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68020       };
68021     } catch (std::exception& e) {
68022       {
68023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68024       };
68025     } catch (Dali::DaliException e) {
68026       {
68027         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68028       };
68029     } catch (...) {
68030       {
68031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68032       };
68033     }
68034   }
68035
68036   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
68037   return jresult;
68038 }
68039
68040
68041 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPanGestureDetector(void * jarg1) {
68042   void * jresult ;
68043   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68044   Dali::PanGestureDetector result;
68045
68046   arg1 = (Dali::Toolkit::Control *)jarg1;
68047   {
68048     try {
68049       result = ((Dali::Toolkit::Control const *)arg1)->GetPanGestureDetector();
68050     } catch (std::out_of_range& e) {
68051       {
68052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68053       };
68054     } catch (std::exception& e) {
68055       {
68056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68057       };
68058     } catch (Dali::DaliException e) {
68059       {
68060         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68061       };
68062     } catch (...) {
68063       {
68064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68065       };
68066     }
68067   }
68068
68069   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
68070   return jresult;
68071 }
68072
68073
68074 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetTapGestureDetector(void * jarg1) {
68075   void * jresult ;
68076   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68077   Dali::TapGestureDetector result;
68078
68079   arg1 = (Dali::Toolkit::Control *)jarg1;
68080   {
68081     try {
68082       result = ((Dali::Toolkit::Control const *)arg1)->GetTapGestureDetector();
68083     } catch (std::out_of_range& e) {
68084       {
68085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68086       };
68087     } catch (std::exception& e) {
68088       {
68089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68090       };
68091     } catch (Dali::DaliException e) {
68092       {
68093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68094       };
68095     } catch (...) {
68096       {
68097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68098       };
68099     }
68100   }
68101
68102   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
68103   return jresult;
68104 }
68105
68106
68107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetLongPressGestureDetector(void * jarg1) {
68108   void * jresult ;
68109   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68110   Dali::LongPressGestureDetector result;
68111
68112   arg1 = (Dali::Toolkit::Control *)jarg1;
68113   {
68114     try {
68115       result = ((Dali::Toolkit::Control const *)arg1)->GetLongPressGestureDetector();
68116     } catch (std::out_of_range& e) {
68117       {
68118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68119       };
68120     } catch (std::exception& e) {
68121       {
68122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68123       };
68124     } catch (Dali::DaliException e) {
68125       {
68126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68127       };
68128     } catch (...) {
68129       {
68130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68131       };
68132     }
68133   }
68134
68135   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
68136   return jresult;
68137 }
68138
68139
68140 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetStyleName(void * jarg1, char * jarg2) {
68141   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68142   std::string *arg2 = 0 ;
68143
68144   arg1 = (Dali::Toolkit::Control *)jarg1;
68145   if (!jarg2) {
68146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
68147     return ;
68148   }
68149   std::string arg2_str(jarg2);
68150   arg2 = &arg2_str;
68151   {
68152     try {
68153       (arg1)->SetStyleName((std::string const &)*arg2);
68154     } catch (std::out_of_range& e) {
68155       {
68156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68157       };
68158     } catch (std::exception& e) {
68159       {
68160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68161       };
68162     } catch (Dali::DaliException e) {
68163       {
68164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68165       };
68166     } catch (...) {
68167       {
68168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68169       };
68170     }
68171   }
68172
68173
68174   //argout typemap for const std::string&
68175
68176 }
68177
68178
68179 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_View_GetStyleName(void * jarg1) {
68180   char * jresult ;
68181   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68182   std::string *result = 0 ;
68183
68184   arg1 = (Dali::Toolkit::Control *)jarg1;
68185   {
68186     try {
68187       result = (std::string *) &((Dali::Toolkit::Control const *)arg1)->GetStyleName();
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 = SWIG_csharp_string_callback(result->c_str());
68208   return jresult;
68209 }
68210
68211
68212 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundColor(void * jarg1, void * jarg2) {
68213   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68214   Dali::Vector4 *arg2 = 0 ;
68215
68216   arg1 = (Dali::Toolkit::Control *)jarg1;
68217   arg2 = (Dali::Vector4 *)jarg2;
68218   if (!arg2) {
68219     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
68220     return ;
68221   }
68222   {
68223     try {
68224       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
68225     } catch (std::out_of_range& e) {
68226       {
68227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68228       };
68229     } catch (std::exception& e) {
68230       {
68231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68232       };
68233     } catch (Dali::DaliException e) {
68234       {
68235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68236       };
68237     } catch (...) {
68238       {
68239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68240       };
68241     }
68242   }
68243
68244 }
68245
68246
68247 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetBackgroundColor(void * jarg1) {
68248   void * jresult ;
68249   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68250   Dali::Vector4 result;
68251
68252   arg1 = (Dali::Toolkit::Control *)jarg1;
68253   {
68254     try {
68255       result = ((Dali::Toolkit::Control const *)arg1)->GetBackgroundColor();
68256     } catch (std::out_of_range& e) {
68257       {
68258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68259       };
68260     } catch (std::exception& e) {
68261       {
68262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68263       };
68264     } catch (Dali::DaliException e) {
68265       {
68266         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68267       };
68268     } catch (...) {
68269       {
68270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68271       };
68272     }
68273   }
68274
68275   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
68276   return jresult;
68277 }
68278
68279
68280 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundImage(void * jarg1, void * jarg2) {
68281   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68282   Dali::Image arg2 ;
68283   Dali::Image *argp2 ;
68284
68285   arg1 = (Dali::Toolkit::Control *)jarg1;
68286   argp2 = (Dali::Image *)jarg2;
68287   if (!argp2) {
68288     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
68289     return ;
68290   }
68291   arg2 = *argp2;
68292   {
68293     try {
68294       (arg1)->SetBackgroundImage(arg2);
68295     } catch (std::out_of_range& e) {
68296       {
68297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68298       };
68299     } catch (std::exception& e) {
68300       {
68301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68302       };
68303     } catch (Dali::DaliException e) {
68304       {
68305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68306       };
68307     } catch (...) {
68308       {
68309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68310       };
68311     }
68312   }
68313
68314 }
68315
68316
68317 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearBackground(void * jarg1) {
68318   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68319
68320   arg1 = (Dali::Toolkit::Control *)jarg1;
68321   {
68322     try {
68323       (arg1)->ClearBackground();
68324     } catch (std::out_of_range& e) {
68325       {
68326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68327       };
68328     } catch (std::exception& e) {
68329       {
68330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68331       };
68332     } catch (Dali::DaliException e) {
68333       {
68334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68335       };
68336     } catch (...) {
68337       {
68338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68339       };
68340     }
68341   }
68342
68343 }
68344
68345
68346 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyEventSignal(void * jarg1) {
68347   void * jresult ;
68348   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68349   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
68350
68351   arg1 = (Dali::Toolkit::Control *)jarg1;
68352   {
68353     try {
68354       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
68355     } catch (std::out_of_range& e) {
68356       {
68357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68358       };
68359     } catch (std::exception& e) {
68360       {
68361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68362       };
68363     } catch (Dali::DaliException e) {
68364       {
68365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68366       };
68367     } catch (...) {
68368       {
68369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68370       };
68371     }
68372   }
68373
68374   jresult = (void *)result;
68375   return jresult;
68376 }
68377
68378
68379 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusGainedSignal(void * jarg1) {
68380   void * jresult ;
68381   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68382   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
68383
68384   arg1 = (Dali::Toolkit::Control *)jarg1;
68385   {
68386     try {
68387       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
68388     } catch (std::out_of_range& e) {
68389       {
68390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68391       };
68392     } catch (std::exception& e) {
68393       {
68394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68395       };
68396     } catch (Dali::DaliException e) {
68397       {
68398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68399       };
68400     } catch (...) {
68401       {
68402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68403       };
68404     }
68405   }
68406
68407   jresult = (void *)result;
68408   return jresult;
68409 }
68410
68411
68412 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusLostSignal(void * jarg1) {
68413   void * jresult ;
68414   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68415   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
68416
68417   arg1 = (Dali::Toolkit::Control *)jarg1;
68418   {
68419     try {
68420       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
68421     } catch (std::out_of_range& e) {
68422       {
68423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68424       };
68425     } catch (std::exception& e) {
68426       {
68427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68428       };
68429     } catch (Dali::DaliException e) {
68430       {
68431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68432       };
68433     } catch (...) {
68434       {
68435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68436       };
68437     }
68438   }
68439
68440   jresult = (void *)result;
68441   return jresult;
68442 }
68443
68444
68445 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_2(void * jarg1) {
68446   void * jresult ;
68447   Dali::Toolkit::Internal::Control *arg1 = 0 ;
68448   Dali::Toolkit::Control *result = 0 ;
68449
68450   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
68451   if (!arg1) {
68452     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
68453     return 0;
68454   }
68455   {
68456     try {
68457       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control(*arg1);
68458     } catch (std::out_of_range& e) {
68459       {
68460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68461       };
68462     } catch (std::exception& e) {
68463       {
68464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68465       };
68466     } catch (Dali::DaliException e) {
68467       {
68468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68469       };
68470     } catch (...) {
68471       {
68472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68473       };
68474     }
68475   }
68476
68477   jresult = (void *)result;
68478   return jresult;
68479 }
68480
68481 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_GetVisualResourceStatus(void * jarg1, int jarg2)
68482 {
68483   int jresult;
68484   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68485   arg1 = (Dali::Toolkit::Control *)jarg1;
68486
68487   if (!arg1) {
68488     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
68489     return 0;
68490   }
68491
68492   Dali::Property::Index arg2 = 0 ;
68493   arg2 = (Dali::Property::Index)jarg2;
68494
68495   Toolkit::Visual::ResourceStatus result;
68496   {
68497     try {
68498       result = arg1->GetVisualResourceStatus(arg2);
68499     } catch (std::out_of_range& e) {
68500       {
68501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68502       };
68503     } catch (std::exception& e) {
68504       {
68505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68506       };
68507     } catch (...) {
68508       {
68509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68510       };
68511     }
68512   }
68513   jresult = (int)(result);
68514   return jresult;
68515 }
68516
68517 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_CreateTransition(void * jarg1, void * jarg2)
68518 {
68519   void * jresult;
68520   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68521   arg1 = (Dali::Toolkit::Control *)jarg1;
68522
68523   Dali::Toolkit::Internal::Control& controlImpl = Dali::Toolkit::Internal::GetImplementation( *arg1 );
68524
68525   Dali::Toolkit::TransitionData *arg2 = 0 ;
68526   Dali::Animation result;
68527
68528   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
68529   if (!arg2) {
68530     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
68531     return 0;
68532   }
68533   {
68534     try {
68535       result = DevelControl::CreateTransition( controlImpl, (Dali::Toolkit::TransitionData const &)*arg2);
68536     } catch (std::out_of_range& e) {
68537       {
68538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68539       };
68540     } catch (std::exception& e) {
68541       {
68542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68543       };
68544     } catch (Dali::DaliException e) {
68545       {
68546         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68547       };
68548     } catch (...) {
68549       {
68550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68551       };
68552     }
68553   }
68554
68555   jresult = new Dali::Animation((const Dali::Animation &)result);
68556   return jresult;
68557 }
68558
68559 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_DoAction(void * jarg1, int jarg2, int jarg3, void * jarg4 )
68560 {
68561   Dali::Toolkit::Control arg1;
68562   Dali::Toolkit::Control *argp1  = (Dali::Toolkit::Control *)jarg1;
68563
68564   if (!argp1) {
68565     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
68566   }
68567   arg1 = *argp1;
68568
68569   Dali::Property::Index arg2 = 0 ;
68570   arg2 = (Dali::Property::Index)jarg2;
68571
68572   Dali::Property::Index arg3 = 0 ;
68573   arg3 = (Dali::Property::Index)jarg3;
68574
68575   Dali::Property::Value arg4;
68576   arg4 = (Dali::Property::Value *)jarg4;
68577
68578   {
68579     try {
68580       DevelControl::DoAction(arg1, arg2, arg3, arg4);
68581     } catch (std::out_of_range& e) {
68582       {
68583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68584       };
68585     } catch (std::exception& e) {
68586       {
68587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68588       };
68589     } catch (...) {
68590       {
68591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68592       };
68593     }
68594   }
68595
68596
68597 }
68598
68599 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceReadySignal(void * jarg1) {
68600   void * jresult ;
68601   Dali::Toolkit::Control *arg1 = 0 ;
68602   Dali::Toolkit::Control::ResourceReadySignalType *result = 0 ;
68603
68604   arg1 = (Dali::Toolkit::Control *)jarg1;
68605   if (!arg1) {
68606     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
68607     return 0;
68608   }
68609   {
68610     try {
68611       result = (Dali::Toolkit::Control::ResourceReadySignalType *) &arg1->ResourceReadySignal();
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 unsigned int SWIGSTDCALL CSharp_Dali_IsResourceReady(void * jarg1) {
68637   unsigned int jresult ;
68638   Dali::Toolkit::Control *arg1 = 0 ;
68639   bool result;
68640
68641   arg1 = (Dali::Toolkit::Control *)jarg1;
68642   if (!arg1) {
68643     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
68644     return 0;
68645   }
68646   {
68647     try {
68648       result = (bool)arg1->IsResourceReady();
68649     } catch (std::out_of_range& e) {
68650       {
68651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68652       };
68653     } catch (std::exception& e) {
68654       {
68655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68656       };
68657     } catch (Dali::DaliException e) {
68658       {
68659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68660       };
68661     } catch (...) {
68662       {
68663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68664       };
68665     }
68666   }
68667
68668   jresult = result;
68669   return jresult;
68670 }
68671
68672
68673 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusManager() {
68674   void * jresult ;
68675   Dali::Toolkit::KeyInputFocusManager *result = 0 ;
68676
68677   {
68678     try {
68679       result = (Dali::Toolkit::KeyInputFocusManager *)new Dali::Toolkit::KeyInputFocusManager();
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 = (void *)result;
68700   return jresult;
68701 }
68702
68703
68704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusManager(void * jarg1) {
68705   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68706
68707   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68708   {
68709     try {
68710       delete arg1;
68711     } catch (std::out_of_range& e) {
68712       {
68713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68714       };
68715     } catch (std::exception& e) {
68716       {
68717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68718       };
68719     } catch (Dali::DaliException e) {
68720       {
68721         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68722       };
68723     } catch (...) {
68724       {
68725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68726       };
68727     }
68728   }
68729
68730 }
68731
68732
68733 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_Get() {
68734   void * jresult ;
68735   Dali::Toolkit::KeyInputFocusManager result;
68736
68737   {
68738     try {
68739       result = Dali::Toolkit::KeyInputFocusManager::Get();
68740     } catch (std::out_of_range& e) {
68741       {
68742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68743       };
68744     } catch (std::exception& e) {
68745       {
68746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68747       };
68748     } catch (Dali::DaliException e) {
68749       {
68750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68751       };
68752     } catch (...) {
68753       {
68754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68755       };
68756     }
68757   }
68758
68759   jresult = new Dali::Toolkit::KeyInputFocusManager((const Dali::Toolkit::KeyInputFocusManager &)result);
68760   return jresult;
68761 }
68762
68763
68764 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SetFocus(void * jarg1, void * jarg2) {
68765   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68766   Dali::Toolkit::Control arg2 ;
68767   Dali::Toolkit::Control *argp2 ;
68768
68769   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68770   argp2 = (Dali::Toolkit::Control *)jarg2;
68771   if (!argp2) {
68772     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
68773     return ;
68774   }
68775   arg2 = *argp2;
68776   {
68777     try {
68778       (arg1)->SetFocus(arg2);
68779     } catch (std::out_of_range& e) {
68780       {
68781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68782       };
68783     } catch (std::exception& e) {
68784       {
68785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68786       };
68787     } catch (Dali::DaliException e) {
68788       {
68789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68790       };
68791     } catch (...) {
68792       {
68793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68794       };
68795     }
68796   }
68797
68798 }
68799
68800
68801 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_GetCurrentFocusControl(void * jarg1) {
68802   void * jresult ;
68803   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68804   Dali::Toolkit::Control result;
68805
68806   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68807   {
68808     try {
68809       result = ((Dali::Toolkit::KeyInputFocusManager const *)arg1)->GetCurrentFocusControl();
68810     } catch (std::out_of_range& e) {
68811       {
68812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68813       };
68814     } catch (std::exception& e) {
68815       {
68816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68817       };
68818     } catch (Dali::DaliException e) {
68819       {
68820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68821       };
68822     } catch (...) {
68823       {
68824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68825       };
68826     }
68827   }
68828
68829   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
68830   return jresult;
68831 }
68832
68833
68834 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_RemoveFocus(void * jarg1, void * jarg2) {
68835   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68836   Dali::Toolkit::Control arg2 ;
68837   Dali::Toolkit::Control *argp2 ;
68838
68839   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68840   argp2 = (Dali::Toolkit::Control *)jarg2;
68841   if (!argp2) {
68842     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
68843     return ;
68844   }
68845   arg2 = *argp2;
68846   {
68847     try {
68848       (arg1)->RemoveFocus(arg2);
68849     } catch (std::out_of_range& e) {
68850       {
68851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68852       };
68853     } catch (std::exception& e) {
68854       {
68855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68856       };
68857     } catch (Dali::DaliException e) {
68858       {
68859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68860       };
68861     } catch (...) {
68862       {
68863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68864       };
68865     }
68866   }
68867
68868 }
68869
68870
68871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_KeyInputFocusChangedSignal(void * jarg1) {
68872   void * jresult ;
68873   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68874   Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *result = 0 ;
68875
68876   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68877   {
68878     try {
68879       result = (Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *) &(arg1)->KeyInputFocusChangedSignal();
68880     } catch (std::out_of_range& e) {
68881       {
68882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68883       };
68884     } catch (std::exception& e) {
68885       {
68886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68887       };
68888     } catch (Dali::DaliException e) {
68889       {
68890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68891       };
68892     } catch (...) {
68893       {
68894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68895       };
68896     }
68897   }
68898
68899   jresult = (void *)result;
68900   return jresult;
68901 }
68902
68903
68904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_0() {
68905   void * jresult ;
68906   Dali::Toolkit::Alignment::Padding *result = 0 ;
68907
68908   {
68909     try {
68910       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding();
68911     } catch (std::out_of_range& e) {
68912       {
68913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68914       };
68915     } catch (std::exception& e) {
68916       {
68917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68918       };
68919     } catch (Dali::DaliException e) {
68920       {
68921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68922       };
68923     } catch (...) {
68924       {
68925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68926       };
68927     }
68928   }
68929
68930   jresult = (void *)result;
68931   return jresult;
68932 }
68933
68934
68935 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
68936   void * jresult ;
68937   float arg1 ;
68938   float arg2 ;
68939   float arg3 ;
68940   float arg4 ;
68941   Dali::Toolkit::Alignment::Padding *result = 0 ;
68942
68943   arg1 = (float)jarg1;
68944   arg2 = (float)jarg2;
68945   arg3 = (float)jarg3;
68946   arg4 = (float)jarg4;
68947   {
68948     try {
68949       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding(arg1,arg2,arg3,arg4);
68950     } catch (std::out_of_range& e) {
68951       {
68952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68953       };
68954     } catch (std::exception& e) {
68955       {
68956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68957       };
68958     } catch (Dali::DaliException e) {
68959       {
68960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68961       };
68962     } catch (...) {
68963       {
68964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68965       };
68966     }
68967   }
68968
68969   jresult = (void *)result;
68970   return jresult;
68971 }
68972
68973
68974 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_set(void * jarg1, float jarg2) {
68975   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68976   float arg2 ;
68977
68978   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68979   arg2 = (float)jarg2;
68980   if (arg1) (arg1)->left = arg2;
68981 }
68982
68983
68984 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_get(void * jarg1) {
68985   float jresult ;
68986   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68987   float result;
68988
68989   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68990   result = (float) ((arg1)->left);
68991   jresult = result;
68992   return jresult;
68993 }
68994
68995
68996 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_set(void * jarg1, float jarg2) {
68997   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68998   float arg2 ;
68999
69000   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
69001   arg2 = (float)jarg2;
69002   if (arg1) (arg1)->right = arg2;
69003 }
69004
69005
69006 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_get(void * jarg1) {
69007   float jresult ;
69008   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
69009   float result;
69010
69011   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
69012   result = (float) ((arg1)->right);
69013   jresult = result;
69014   return jresult;
69015 }
69016
69017
69018 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_set(void * jarg1, float jarg2) {
69019   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
69020   float arg2 ;
69021
69022   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
69023   arg2 = (float)jarg2;
69024   if (arg1) (arg1)->top = arg2;
69025 }
69026
69027
69028 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_get(void * jarg1) {
69029   float jresult ;
69030   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
69031   float result;
69032
69033   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
69034   result = (float) ((arg1)->top);
69035   jresult = result;
69036   return jresult;
69037 }
69038
69039
69040 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_set(void * jarg1, float jarg2) {
69041   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
69042   float arg2 ;
69043
69044   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
69045   arg2 = (float)jarg2;
69046   if (arg1) (arg1)->bottom = arg2;
69047 }
69048
69049
69050 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_get(void * jarg1) {
69051   float jresult ;
69052   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
69053   float result;
69054
69055   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
69056   result = (float) ((arg1)->bottom);
69057   jresult = result;
69058   return jresult;
69059 }
69060
69061
69062 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment_Padding(void * jarg1) {
69063   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
69064
69065   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
69066   {
69067     try {
69068       delete arg1;
69069     } catch (std::out_of_range& e) {
69070       {
69071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69072       };
69073     } catch (std::exception& e) {
69074       {
69075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69076       };
69077     } catch (Dali::DaliException e) {
69078       {
69079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69080       };
69081     } catch (...) {
69082       {
69083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69084       };
69085     }
69086   }
69087
69088 }
69089
69090
69091 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_0() {
69092   void * jresult ;
69093   Dali::Toolkit::Alignment *result = 0 ;
69094
69095   {
69096     try {
69097       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment();
69098     } catch (std::out_of_range& e) {
69099       {
69100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69101       };
69102     } catch (std::exception& e) {
69103       {
69104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69105       };
69106     } catch (Dali::DaliException e) {
69107       {
69108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69109       };
69110     } catch (...) {
69111       {
69112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69113       };
69114     }
69115   }
69116
69117   jresult = (void *)result;
69118   return jresult;
69119 }
69120
69121
69122 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_0(int jarg1, int jarg2) {
69123   void * jresult ;
69124   Dali::Toolkit::Alignment::Type arg1 ;
69125   Dali::Toolkit::Alignment::Type arg2 ;
69126   Dali::Toolkit::Alignment result;
69127
69128   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
69129   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
69130   {
69131     try {
69132       result = Dali::Toolkit::Alignment::New(arg1,arg2);
69133     } catch (std::out_of_range& e) {
69134       {
69135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69136       };
69137     } catch (std::exception& e) {
69138       {
69139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69140       };
69141     } catch (Dali::DaliException e) {
69142       {
69143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69144       };
69145     } catch (...) {
69146       {
69147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69148       };
69149     }
69150   }
69151
69152   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
69153   return jresult;
69154 }
69155
69156
69157 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_1(int jarg1) {
69158   void * jresult ;
69159   Dali::Toolkit::Alignment::Type arg1 ;
69160   Dali::Toolkit::Alignment result;
69161
69162   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
69163   {
69164     try {
69165       result = Dali::Toolkit::Alignment::New(arg1);
69166     } catch (std::out_of_range& e) {
69167       {
69168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69169       };
69170     } catch (std::exception& e) {
69171       {
69172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69173       };
69174     } catch (Dali::DaliException e) {
69175       {
69176         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69177       };
69178     } catch (...) {
69179       {
69180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69181       };
69182     }
69183   }
69184
69185   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
69186   return jresult;
69187 }
69188
69189
69190 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_2() {
69191   void * jresult ;
69192   Dali::Toolkit::Alignment result;
69193
69194   {
69195     try {
69196       result = Dali::Toolkit::Alignment::New();
69197     } catch (std::out_of_range& e) {
69198       {
69199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69200       };
69201     } catch (std::exception& e) {
69202       {
69203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69204       };
69205     } catch (Dali::DaliException e) {
69206       {
69207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69208       };
69209     } catch (...) {
69210       {
69211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69212       };
69213     }
69214   }
69215
69216   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
69217   return jresult;
69218 }
69219
69220
69221 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_1(void * jarg1) {
69222   void * jresult ;
69223   Dali::Toolkit::Alignment *arg1 = 0 ;
69224   Dali::Toolkit::Alignment *result = 0 ;
69225
69226   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69227   if (!arg1) {
69228     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
69229     return 0;
69230   }
69231   {
69232     try {
69233       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment((Dali::Toolkit::Alignment const &)*arg1);
69234     } catch (std::out_of_range& e) {
69235       {
69236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69237       };
69238     } catch (std::exception& e) {
69239       {
69240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69241       };
69242     } catch (Dali::DaliException e) {
69243       {
69244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69245       };
69246     } catch (...) {
69247       {
69248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69249       };
69250     }
69251   }
69252
69253   jresult = (void *)result;
69254   return jresult;
69255 }
69256
69257
69258 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment(void * jarg1) {
69259   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69260
69261   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69262   {
69263     try {
69264       delete arg1;
69265     } catch (std::out_of_range& e) {
69266       {
69267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69268       };
69269     } catch (std::exception& e) {
69270       {
69271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69272       };
69273     } catch (Dali::DaliException e) {
69274       {
69275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69276       };
69277     } catch (...) {
69278       {
69279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69280       };
69281     }
69282   }
69283
69284 }
69285
69286
69287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_DownCast(void * jarg1) {
69288   void * jresult ;
69289   Dali::BaseHandle arg1 ;
69290   Dali::BaseHandle *argp1 ;
69291   Dali::Toolkit::Alignment result;
69292
69293   argp1 = (Dali::BaseHandle *)jarg1;
69294   if (!argp1) {
69295     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
69296     return 0;
69297   }
69298   arg1 = *argp1;
69299   {
69300     try {
69301       result = Dali::Toolkit::Alignment::DownCast(arg1);
69302     } catch (std::out_of_range& e) {
69303       {
69304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69305       };
69306     } catch (std::exception& e) {
69307       {
69308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69309       };
69310     } catch (Dali::DaliException e) {
69311       {
69312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69313       };
69314     } catch (...) {
69315       {
69316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69317       };
69318     }
69319   }
69320
69321   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
69322   return jresult;
69323 }
69324
69325
69326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetAlignmentType(void * jarg1, int jarg2) {
69327   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69328   Dali::Toolkit::Alignment::Type arg2 ;
69329
69330   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69331   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
69332   {
69333     try {
69334       (arg1)->SetAlignmentType(arg2);
69335     } catch (std::out_of_range& e) {
69336       {
69337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69338       };
69339     } catch (std::exception& e) {
69340       {
69341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69342       };
69343     } catch (Dali::DaliException e) {
69344       {
69345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69346       };
69347     } catch (...) {
69348       {
69349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69350       };
69351     }
69352   }
69353
69354 }
69355
69356
69357 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetAlignmentType(void * jarg1) {
69358   int jresult ;
69359   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69360   Dali::Toolkit::Alignment::Type result;
69361
69362   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69363   {
69364     try {
69365       result = (Dali::Toolkit::Alignment::Type)((Dali::Toolkit::Alignment const *)arg1)->GetAlignmentType();
69366     } catch (std::out_of_range& e) {
69367       {
69368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69369       };
69370     } catch (std::exception& e) {
69371       {
69372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69373       };
69374     } catch (Dali::DaliException e) {
69375       {
69376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69377       };
69378     } catch (...) {
69379       {
69380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69381       };
69382     }
69383   }
69384
69385   jresult = (int)result;
69386   return jresult;
69387 }
69388
69389
69390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetScaling(void * jarg1, int jarg2) {
69391   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69392   Dali::Toolkit::Alignment::Scaling arg2 ;
69393
69394   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69395   arg2 = (Dali::Toolkit::Alignment::Scaling)jarg2;
69396   {
69397     try {
69398       (arg1)->SetScaling(arg2);
69399     } catch (std::out_of_range& e) {
69400       {
69401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69402       };
69403     } catch (std::exception& e) {
69404       {
69405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69406       };
69407     } catch (Dali::DaliException e) {
69408       {
69409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69410       };
69411     } catch (...) {
69412       {
69413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69414       };
69415     }
69416   }
69417
69418 }
69419
69420
69421 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetScaling(void * jarg1) {
69422   int jresult ;
69423   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69424   Dali::Toolkit::Alignment::Scaling result;
69425
69426   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69427   {
69428     try {
69429       result = (Dali::Toolkit::Alignment::Scaling)((Dali::Toolkit::Alignment const *)arg1)->GetScaling();
69430     } catch (std::out_of_range& e) {
69431       {
69432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69433       };
69434     } catch (std::exception& e) {
69435       {
69436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69437       };
69438     } catch (Dali::DaliException e) {
69439       {
69440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69441       };
69442     } catch (...) {
69443       {
69444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69445       };
69446     }
69447   }
69448
69449   jresult = (int)result;
69450   return jresult;
69451 }
69452
69453
69454 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetPadding(void * jarg1, void * jarg2) {
69455   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69456   Dali::Toolkit::Alignment::Padding *arg2 = 0 ;
69457
69458   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69459   arg2 = (Dali::Toolkit::Alignment::Padding *)jarg2;
69460   if (!arg2) {
69461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment::Padding const & type is null", 0);
69462     return ;
69463   }
69464   {
69465     try {
69466       (arg1)->SetPadding((Dali::Toolkit::Alignment::Padding const &)*arg2);
69467     } catch (std::out_of_range& e) {
69468       {
69469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69470       };
69471     } catch (std::exception& e) {
69472       {
69473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69474       };
69475     } catch (Dali::DaliException e) {
69476       {
69477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69478       };
69479     } catch (...) {
69480       {
69481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69482       };
69483     }
69484   }
69485
69486 }
69487
69488
69489 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_GetPadding(void * jarg1) {
69490   void * jresult ;
69491   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69492   Dali::Toolkit::Alignment::Padding *result = 0 ;
69493
69494   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69495   {
69496     try {
69497       result = (Dali::Toolkit::Alignment::Padding *) &((Dali::Toolkit::Alignment const *)arg1)->GetPadding();
69498     } catch (std::out_of_range& e) {
69499       {
69500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69501       };
69502     } catch (std::exception& e) {
69503       {
69504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69505       };
69506     } catch (Dali::DaliException e) {
69507       {
69508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69509       };
69510     } catch (...) {
69511       {
69512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69513       };
69514     }
69515   }
69516
69517   jresult = (void *)result;
69518   return jresult;
69519 }
69520
69521
69522 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_Assign(void * jarg1, void * jarg2) {
69523   void * jresult ;
69524   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69525   Dali::Toolkit::Alignment *arg2 = 0 ;
69526   Dali::Toolkit::Alignment *result = 0 ;
69527
69528   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69529   arg2 = (Dali::Toolkit::Alignment *)jarg2;
69530   if (!arg2) {
69531     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
69532     return 0;
69533   }
69534   {
69535     try {
69536       result = (Dali::Toolkit::Alignment *) &(arg1)->operator =((Dali::Toolkit::Alignment const &)*arg2);
69537     } catch (std::out_of_range& e) {
69538       {
69539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69540       };
69541     } catch (std::exception& e) {
69542       {
69543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69544       };
69545     } catch (Dali::DaliException e) {
69546       {
69547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69548       };
69549     } catch (...) {
69550       {
69551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69552       };
69553     }
69554   }
69555
69556   jresult = (void *)result;
69557   return jresult;
69558 }
69559
69560
69561 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_DISABLED_get() {
69562   int jresult ;
69563   int result;
69564
69565   result = (int)Dali::Toolkit::Button::Property::DISABLED;
69566   jresult = (int)result;
69567   return jresult;
69568 }
69569
69570
69571 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_AUTO_REPEATING_get() {
69572   int jresult ;
69573   int result;
69574
69575   result = (int)Dali::Toolkit::Button::Property::AUTO_REPEATING;
69576   jresult = (int)result;
69577   return jresult;
69578 }
69579
69580
69581 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_INITIAL_AUTO_REPEATING_DELAY_get() {
69582   int jresult ;
69583   int result;
69584
69585   result = (int)Dali::Toolkit::Button::Property::INITIAL_AUTO_REPEATING_DELAY;
69586   jresult = (int)result;
69587   return jresult;
69588 }
69589
69590
69591 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_NEXT_AUTO_REPEATING_DELAY_get() {
69592   int jresult ;
69593   int result;
69594
69595   result = (int)Dali::Toolkit::Button::Property::NEXT_AUTO_REPEATING_DELAY;
69596   jresult = (int)result;
69597   return jresult;
69598 }
69599
69600
69601 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_TOGGLABLE_get() {
69602   int jresult ;
69603   int result;
69604
69605   result = (int)Dali::Toolkit::Button::Property::TOGGLABLE;
69606   jresult = (int)result;
69607   return jresult;
69608 }
69609
69610
69611 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_get() {
69612   int jresult ;
69613   int result;
69614
69615   result = (int)Dali::Toolkit::Button::Property::SELECTED;
69616   jresult = (int)result;
69617   return jresult;
69618 }
69619
69620
69621 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_UNSELECTED_COLOR_get() {
69622   int jresult ;
69623   int result;
69624
69625   result = (int)Dali::Toolkit::Button::Property::UNSELECTED_COLOR;
69626   jresult = (int)result;
69627   return jresult;
69628 }
69629
69630
69631 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_COLOR_get() {
69632   int jresult ;
69633   int result;
69634
69635   result = (int)Dali::Toolkit::Button::Property::SELECTED_COLOR;
69636   jresult = (int)result;
69637   return jresult;
69638 }
69639
69640
69641 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_get() {
69642   int jresult ;
69643   int result;
69644
69645   result = (int)Dali::Toolkit::Button::Property::LABEL;
69646   jresult = (int)result;
69647   return jresult;
69648 }
69649
69650
69651 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_TEXT_get() {
69652   int jresult ;
69653   int result;
69654
69655   result = (int)Dali::Toolkit::Button::Property::LABEL_TEXT;
69656   jresult = (int)result;
69657   return jresult;
69658 }
69659
69660
69661 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button_Property() {
69662   void * jresult ;
69663   Dali::Toolkit::Button::Property *result = 0 ;
69664
69665   {
69666     try {
69667       result = (Dali::Toolkit::Button::Property *)new Dali::Toolkit::Button::Property();
69668     } catch (std::out_of_range& e) {
69669       {
69670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69671       };
69672     } catch (std::exception& e) {
69673       {
69674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69675       };
69676     } catch (Dali::DaliException e) {
69677       {
69678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69679       };
69680     } catch (...) {
69681       {
69682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69683       };
69684     }
69685   }
69686
69687   jresult = (void *)result;
69688   return jresult;
69689 }
69690
69691
69692 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button_Property(void * jarg1) {
69693   Dali::Toolkit::Button::Property *arg1 = (Dali::Toolkit::Button::Property *) 0 ;
69694
69695   arg1 = (Dali::Toolkit::Button::Property *)jarg1;
69696   {
69697     try {
69698       delete arg1;
69699     } catch (std::out_of_range& e) {
69700       {
69701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69702       };
69703     } catch (std::exception& e) {
69704       {
69705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69706       };
69707     } catch (Dali::DaliException e) {
69708       {
69709         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69710       };
69711     } catch (...) {
69712       {
69713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69714       };
69715     }
69716   }
69717
69718 }
69719
69720
69721 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_0() {
69722   void * jresult ;
69723   Dali::Toolkit::Button *result = 0 ;
69724
69725   {
69726     try {
69727       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button();
69728     } catch (std::out_of_range& e) {
69729       {
69730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69731       };
69732     } catch (std::exception& e) {
69733       {
69734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69735       };
69736     } catch (Dali::DaliException e) {
69737       {
69738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69739       };
69740     } catch (...) {
69741       {
69742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69743       };
69744     }
69745   }
69746
69747   jresult = (void *)result;
69748   return jresult;
69749 }
69750
69751
69752 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_1(void * jarg1) {
69753   void * jresult ;
69754   Dali::Toolkit::Button *arg1 = 0 ;
69755   Dali::Toolkit::Button *result = 0 ;
69756
69757   arg1 = (Dali::Toolkit::Button *)jarg1;
69758   if (!arg1) {
69759     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
69760     return 0;
69761   }
69762   {
69763     try {
69764       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button((Dali::Toolkit::Button const &)*arg1);
69765     } catch (std::out_of_range& e) {
69766       {
69767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69768       };
69769     } catch (std::exception& e) {
69770       {
69771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69772       };
69773     } catch (Dali::DaliException e) {
69774       {
69775         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69776       };
69777     } catch (...) {
69778       {
69779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69780       };
69781     }
69782   }
69783
69784   jresult = (void *)result;
69785   return jresult;
69786 }
69787
69788
69789 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_Assign(void * jarg1, void * jarg2) {
69790   void * jresult ;
69791   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69792   Dali::Toolkit::Button *arg2 = 0 ;
69793   Dali::Toolkit::Button *result = 0 ;
69794
69795   arg1 = (Dali::Toolkit::Button *)jarg1;
69796   arg2 = (Dali::Toolkit::Button *)jarg2;
69797   if (!arg2) {
69798     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
69799     return 0;
69800   }
69801   {
69802     try {
69803       result = (Dali::Toolkit::Button *) &(arg1)->operator =((Dali::Toolkit::Button const &)*arg2);
69804     } catch (std::out_of_range& e) {
69805       {
69806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69807       };
69808     } catch (std::exception& e) {
69809       {
69810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69811       };
69812     } catch (Dali::DaliException e) {
69813       {
69814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69815       };
69816     } catch (...) {
69817       {
69818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69819       };
69820     }
69821   }
69822
69823   jresult = (void *)result;
69824   return jresult;
69825 }
69826
69827
69828 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_DownCast(void * jarg1) {
69829   void * jresult ;
69830   Dali::BaseHandle arg1 ;
69831   Dali::BaseHandle *argp1 ;
69832   Dali::Toolkit::Button result;
69833
69834   argp1 = (Dali::BaseHandle *)jarg1;
69835   if (!argp1) {
69836     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
69837     return 0;
69838   }
69839   arg1 = *argp1;
69840   {
69841     try {
69842       result = Dali::Toolkit::Button::DownCast(arg1);
69843     } catch (std::out_of_range& e) {
69844       {
69845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69846       };
69847     } catch (std::exception& e) {
69848       {
69849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69850       };
69851     } catch (Dali::DaliException e) {
69852       {
69853         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69854       };
69855     } catch (...) {
69856       {
69857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69858       };
69859     }
69860   }
69861
69862   jresult = new Dali::Toolkit::Button((const Dali::Toolkit::Button &)result);
69863   return jresult;
69864 }
69865
69866
69867 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button(void * jarg1) {
69868   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69869
69870   arg1 = (Dali::Toolkit::Button *)jarg1;
69871   {
69872     try {
69873       delete arg1;
69874     } catch (std::out_of_range& e) {
69875       {
69876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69877       };
69878     } catch (std::exception& e) {
69879       {
69880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69881       };
69882     } catch (Dali::DaliException e) {
69883       {
69884         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69885       };
69886     } catch (...) {
69887       {
69888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69889       };
69890     }
69891   }
69892
69893 }
69894
69895
69896 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsDisabled(void * jarg1) {
69897   unsigned int jresult ;
69898   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69899   bool result;
69900
69901   arg1 = (Dali::Toolkit::Button *)jarg1;
69902   {
69903     try {
69904       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsDisabled();
69905     } catch (std::out_of_range& e) {
69906       {
69907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69908       };
69909     } catch (std::exception& e) {
69910       {
69911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69912       };
69913     } catch (Dali::DaliException e) {
69914       {
69915         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69916       };
69917     } catch (...) {
69918       {
69919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69920       };
69921     }
69922   }
69923
69924   jresult = result;
69925   return jresult;
69926 }
69927
69928
69929 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsAutoRepeating(void * jarg1) {
69930   unsigned int jresult ;
69931   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69932   bool result;
69933
69934   arg1 = (Dali::Toolkit::Button *)jarg1;
69935   {
69936     try {
69937       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsAutoRepeating();
69938     } catch (std::out_of_range& e) {
69939       {
69940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69941       };
69942     } catch (std::exception& e) {
69943       {
69944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69945       };
69946     } catch (Dali::DaliException e) {
69947       {
69948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69949       };
69950     } catch (...) {
69951       {
69952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69953       };
69954     }
69955   }
69956
69957   jresult = result;
69958   return jresult;
69959 }
69960
69961
69962 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetInitialAutoRepeatingDelay(void * jarg1) {
69963   float jresult ;
69964   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69965   float result;
69966
69967   arg1 = (Dali::Toolkit::Button *)jarg1;
69968   {
69969     try {
69970       result = (float)((Dali::Toolkit::Button const *)arg1)->GetInitialAutoRepeatingDelay();
69971     } catch (std::out_of_range& e) {
69972       {
69973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69974       };
69975     } catch (std::exception& e) {
69976       {
69977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69978       };
69979     } catch (Dali::DaliException e) {
69980       {
69981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69982       };
69983     } catch (...) {
69984       {
69985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69986       };
69987     }
69988   }
69989
69990   jresult = result;
69991   return jresult;
69992 }
69993
69994
69995 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetNextAutoRepeatingDelay(void * jarg1) {
69996   float jresult ;
69997   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69998   float result;
69999
70000   arg1 = (Dali::Toolkit::Button *)jarg1;
70001   {
70002     try {
70003       result = (float)((Dali::Toolkit::Button const *)arg1)->GetNextAutoRepeatingDelay();
70004     } catch (std::out_of_range& e) {
70005       {
70006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70007       };
70008     } catch (std::exception& e) {
70009       {
70010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70011       };
70012     } catch (Dali::DaliException e) {
70013       {
70014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70015       };
70016     } catch (...) {
70017       {
70018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70019       };
70020     }
70021   }
70022
70023   jresult = result;
70024   return jresult;
70025 }
70026
70027
70028 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsTogglableButton(void * jarg1) {
70029   unsigned int jresult ;
70030   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70031   bool result;
70032
70033   arg1 = (Dali::Toolkit::Button *)jarg1;
70034   {
70035     try {
70036       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsTogglableButton();
70037     } catch (std::out_of_range& e) {
70038       {
70039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70040       };
70041     } catch (std::exception& e) {
70042       {
70043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70044       };
70045     } catch (Dali::DaliException e) {
70046       {
70047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70048       };
70049     } catch (...) {
70050       {
70051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70052       };
70053     }
70054   }
70055
70056   jresult = result;
70057   return jresult;
70058 }
70059
70060
70061 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsSelected(void * jarg1) {
70062   unsigned int jresult ;
70063   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70064   bool result;
70065
70066   arg1 = (Dali::Toolkit::Button *)jarg1;
70067   {
70068     try {
70069       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsSelected();
70070     } catch (std::out_of_range& e) {
70071       {
70072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70073       };
70074     } catch (std::exception& e) {
70075       {
70076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70077       };
70078     } catch (Dali::DaliException e) {
70079       {
70080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70081       };
70082     } catch (...) {
70083       {
70084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70085       };
70086     }
70087   }
70088
70089   jresult = result;
70090   return jresult;
70091 }
70092
70093
70094 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetAnimationTime(void * jarg1) {
70095   float jresult ;
70096   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70097   float result;
70098
70099   arg1 = (Dali::Toolkit::Button *)jarg1;
70100   {
70101     try {
70102       result = (float)((Dali::Toolkit::Button const *)arg1)->GetAnimationTime();
70103     } catch (std::out_of_range& e) {
70104       {
70105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70106       };
70107     } catch (std::exception& e) {
70108       {
70109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70110       };
70111     } catch (Dali::DaliException e) {
70112       {
70113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70114       };
70115     } catch (...) {
70116       {
70117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70118       };
70119     }
70120   }
70121
70122   jresult = result;
70123   return jresult;
70124 }
70125
70126
70127 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Button_GetLabelText(void * jarg1) {
70128   char * jresult ;
70129   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70130   std::string result;
70131
70132   arg1 = (Dali::Toolkit::Button *)jarg1;
70133   {
70134     try {
70135       result = ((Dali::Toolkit::Button const *)arg1)->GetLabelText();
70136     } catch (std::out_of_range& e) {
70137       {
70138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70139       };
70140     } catch (std::exception& e) {
70141       {
70142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70143       };
70144     } catch (Dali::DaliException e) {
70145       {
70146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70147       };
70148     } catch (...) {
70149       {
70150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70151       };
70152     }
70153   }
70154
70155   jresult = SWIG_csharp_string_callback((&result)->c_str());
70156   return jresult;
70157 }
70158
70159
70160 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetLabel(void * jarg1, void * jarg2) {
70161   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70162   Dali::Actor arg2 ;
70163   Dali::Actor *argp2 ;
70164
70165   arg1 = (Dali::Toolkit::Button *)jarg1;
70166   argp2 = (Dali::Actor *)jarg2;
70167   if (!argp2) {
70168     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70169     return ;
70170   }
70171   arg2 = *argp2;
70172   {
70173     try {
70174       (arg1)->SetLabel(arg2);
70175     } catch (std::out_of_range& e) {
70176       {
70177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70178       };
70179     } catch (std::exception& e) {
70180       {
70181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70182       };
70183     } catch (Dali::DaliException e) {
70184       {
70185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70186       };
70187     } catch (...) {
70188       {
70189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70190       };
70191     }
70192   }
70193
70194 }
70195
70196
70197 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetButtonImage(void * jarg1, void * jarg2) {
70198   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70199   Dali::Image arg2 ;
70200   Dali::Image *argp2 ;
70201
70202   arg1 = (Dali::Toolkit::Button *)jarg1;
70203   argp2 = (Dali::Image *)jarg2;
70204   if (!argp2) {
70205     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
70206     return ;
70207   }
70208   arg2 = *argp2;
70209   {
70210     try {
70211       (arg1)->SetButtonImage(arg2);
70212     } catch (std::out_of_range& e) {
70213       {
70214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70215       };
70216     } catch (std::exception& e) {
70217       {
70218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70219       };
70220     } catch (Dali::DaliException e) {
70221       {
70222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70223       };
70224     } catch (...) {
70225       {
70226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70227       };
70228     }
70229   }
70230
70231 }
70232
70233
70234 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetSelectedImage(void * jarg1, void * jarg2) {
70235   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70236   Dali::Image arg2 ;
70237   Dali::Image *argp2 ;
70238
70239   arg1 = (Dali::Toolkit::Button *)jarg1;
70240   argp2 = (Dali::Image *)jarg2;
70241   if (!argp2) {
70242     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
70243     return ;
70244   }
70245   arg2 = *argp2;
70246   {
70247     try {
70248       (arg1)->SetSelectedImage(arg2);
70249     } catch (std::out_of_range& e) {
70250       {
70251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70252       };
70253     } catch (std::exception& e) {
70254       {
70255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70256       };
70257     } catch (Dali::DaliException e) {
70258       {
70259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70260       };
70261     } catch (...) {
70262       {
70263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70264       };
70265     }
70266   }
70267
70268 }
70269
70270
70271 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetButtonImage(void * jarg1) {
70272   void * jresult ;
70273   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70274   Dali::Actor result;
70275
70276   arg1 = (Dali::Toolkit::Button *)jarg1;
70277   {
70278     try {
70279       result = ((Dali::Toolkit::Button const *)arg1)->GetButtonImage();
70280     } catch (std::out_of_range& e) {
70281       {
70282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70283       };
70284     } catch (std::exception& e) {
70285       {
70286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70287       };
70288     } catch (Dali::DaliException e) {
70289       {
70290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70291       };
70292     } catch (...) {
70293       {
70294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70295       };
70296     }
70297   }
70298
70299   jresult = new Dali::Actor((const Dali::Actor &)result);
70300   return jresult;
70301 }
70302
70303
70304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetSelectedImage(void * jarg1) {
70305   void * jresult ;
70306   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70307   Dali::Actor result;
70308
70309   arg1 = (Dali::Toolkit::Button *)jarg1;
70310   {
70311     try {
70312       result = ((Dali::Toolkit::Button const *)arg1)->GetSelectedImage();
70313     } catch (std::out_of_range& e) {
70314       {
70315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70316       };
70317     } catch (std::exception& e) {
70318       {
70319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70320       };
70321     } catch (Dali::DaliException e) {
70322       {
70323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70324       };
70325     } catch (...) {
70326       {
70327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70328       };
70329     }
70330   }
70331
70332   jresult = new Dali::Actor((const Dali::Actor &)result);
70333   return jresult;
70334 }
70335
70336
70337 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_PressedSignal(void * jarg1) {
70338   void * jresult ;
70339   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70340   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
70341
70342   arg1 = (Dali::Toolkit::Button *)jarg1;
70343   {
70344     try {
70345       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->PressedSignal();
70346     } catch (std::out_of_range& e) {
70347       {
70348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70349       };
70350     } catch (std::exception& e) {
70351       {
70352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70353       };
70354     } catch (Dali::DaliException e) {
70355       {
70356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70357       };
70358     } catch (...) {
70359       {
70360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70361       };
70362     }
70363   }
70364
70365   jresult = (void *)result;
70366   return jresult;
70367 }
70368
70369
70370 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ReleasedSignal(void * jarg1) {
70371   void * jresult ;
70372   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70373   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
70374
70375   arg1 = (Dali::Toolkit::Button *)jarg1;
70376   {
70377     try {
70378       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ReleasedSignal();
70379     } catch (std::out_of_range& e) {
70380       {
70381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70382       };
70383     } catch (std::exception& e) {
70384       {
70385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70386       };
70387     } catch (Dali::DaliException e) {
70388       {
70389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70390       };
70391     } catch (...) {
70392       {
70393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70394       };
70395     }
70396   }
70397
70398   jresult = (void *)result;
70399   return jresult;
70400 }
70401
70402
70403 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ClickedSignal(void * jarg1) {
70404   void * jresult ;
70405   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70406   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
70407
70408   arg1 = (Dali::Toolkit::Button *)jarg1;
70409   {
70410     try {
70411       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ClickedSignal();
70412     } catch (std::out_of_range& e) {
70413       {
70414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70415       };
70416     } catch (std::exception& e) {
70417       {
70418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70419       };
70420     } catch (Dali::DaliException e) {
70421       {
70422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70423       };
70424     } catch (...) {
70425       {
70426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70427       };
70428     }
70429   }
70430
70431   jresult = (void *)result;
70432   return jresult;
70433 }
70434
70435
70436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_StateChangedSignal(void * jarg1) {
70437   void * jresult ;
70438   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70439   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
70440
70441   arg1 = (Dali::Toolkit::Button *)jarg1;
70442   {
70443     try {
70444       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->StateChangedSignal();
70445     } catch (std::out_of_range& e) {
70446       {
70447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70448       };
70449     } catch (std::exception& e) {
70450       {
70451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70452       };
70453     } catch (Dali::DaliException e) {
70454       {
70455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70456       };
70457     } catch (...) {
70458       {
70459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70460       };
70461     }
70462   }
70463
70464   jresult = (void *)result;
70465   return jresult;
70466 }
70467
70468
70469 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_0() {
70470   void * jresult ;
70471   Dali::Toolkit::CheckBoxButton *result = 0 ;
70472
70473   {
70474     try {
70475       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton();
70476     } catch (std::out_of_range& e) {
70477       {
70478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70479       };
70480     } catch (std::exception& e) {
70481       {
70482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70483       };
70484     } catch (Dali::DaliException e) {
70485       {
70486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70487       };
70488     } catch (...) {
70489       {
70490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70491       };
70492     }
70493   }
70494
70495   jresult = (void *)result;
70496   return jresult;
70497 }
70498
70499
70500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_1(void * jarg1) {
70501   void * jresult ;
70502   Dali::Toolkit::CheckBoxButton *arg1 = 0 ;
70503   Dali::Toolkit::CheckBoxButton *result = 0 ;
70504
70505   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
70506   if (!arg1) {
70507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
70508     return 0;
70509   }
70510   {
70511     try {
70512       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton((Dali::Toolkit::CheckBoxButton const &)*arg1);
70513     } catch (std::out_of_range& e) {
70514       {
70515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70516       };
70517     } catch (std::exception& e) {
70518       {
70519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70520       };
70521     } catch (Dali::DaliException e) {
70522       {
70523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70524       };
70525     } catch (...) {
70526       {
70527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70528       };
70529     }
70530   }
70531
70532   jresult = (void *)result;
70533   return jresult;
70534 }
70535
70536
70537 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_Assign(void * jarg1, void * jarg2) {
70538   void * jresult ;
70539   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
70540   Dali::Toolkit::CheckBoxButton *arg2 = 0 ;
70541   Dali::Toolkit::CheckBoxButton *result = 0 ;
70542
70543   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
70544   arg2 = (Dali::Toolkit::CheckBoxButton *)jarg2;
70545   if (!arg2) {
70546     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
70547     return 0;
70548   }
70549   {
70550     try {
70551       result = (Dali::Toolkit::CheckBoxButton *) &(arg1)->operator =((Dali::Toolkit::CheckBoxButton const &)*arg2);
70552     } catch (std::out_of_range& e) {
70553       {
70554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70555       };
70556     } catch (std::exception& e) {
70557       {
70558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70559       };
70560     } catch (Dali::DaliException e) {
70561       {
70562         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70563       };
70564     } catch (...) {
70565       {
70566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70567       };
70568     }
70569   }
70570
70571   jresult = (void *)result;
70572   return jresult;
70573 }
70574
70575
70576 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CheckBoxButton(void * jarg1) {
70577   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
70578
70579   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
70580   {
70581     try {
70582       delete arg1;
70583     } catch (std::out_of_range& e) {
70584       {
70585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70586       };
70587     } catch (std::exception& e) {
70588       {
70589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70590       };
70591     } catch (Dali::DaliException e) {
70592       {
70593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70594       };
70595     } catch (...) {
70596       {
70597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70598       };
70599     }
70600   }
70601
70602 }
70603
70604
70605 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_New() {
70606   void * jresult ;
70607   Dali::Toolkit::CheckBoxButton result;
70608
70609   {
70610     try {
70611       result = Dali::Toolkit::CheckBoxButton::New();
70612     } catch (std::out_of_range& e) {
70613       {
70614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70615       };
70616     } catch (std::exception& e) {
70617       {
70618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70619       };
70620     } catch (Dali::DaliException e) {
70621       {
70622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70623       };
70624     } catch (...) {
70625       {
70626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70627       };
70628     }
70629   }
70630
70631   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
70632   return jresult;
70633 }
70634
70635
70636 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_DownCast(void * jarg1) {
70637   void * jresult ;
70638   Dali::BaseHandle arg1 ;
70639   Dali::BaseHandle *argp1 ;
70640   Dali::Toolkit::CheckBoxButton result;
70641
70642   argp1 = (Dali::BaseHandle *)jarg1;
70643   if (!argp1) {
70644     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
70645     return 0;
70646   }
70647   arg1 = *argp1;
70648   {
70649     try {
70650       result = Dali::Toolkit::CheckBoxButton::DownCast(arg1);
70651     } catch (std::out_of_range& e) {
70652       {
70653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70654       };
70655     } catch (std::exception& e) {
70656       {
70657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70658       };
70659     } catch (Dali::DaliException e) {
70660       {
70661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70662       };
70663     } catch (...) {
70664       {
70665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70666       };
70667     }
70668   }
70669
70670   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
70671   return jresult;
70672 }
70673
70674
70675 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_UNSELECTED_ICON_get() {
70676   int jresult ;
70677   int result;
70678
70679   result = (int)Dali::Toolkit::PushButton::Property::UNSELECTED_ICON;
70680   jresult = (int)result;
70681   return jresult;
70682 }
70683
70684
70685 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_SELECTED_ICON_get() {
70686   int jresult ;
70687   int result;
70688
70689   result = (int)Dali::Toolkit::PushButton::Property::SELECTED_ICON;
70690   jresult = (int)result;
70691   return jresult;
70692 }
70693
70694
70695 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_ALIGNMENT_get() {
70696   int jresult ;
70697   int result;
70698
70699   result = (int)Dali::Toolkit::PushButton::Property::ICON_ALIGNMENT;
70700   jresult = (int)result;
70701   return jresult;
70702 }
70703
70704
70705 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_LABEL_PADDING_get() {
70706   int jresult ;
70707   int result;
70708
70709   result = (int)Dali::Toolkit::PushButton::Property::LABEL_PADDING;
70710   jresult = (int)result;
70711   return jresult;
70712 }
70713
70714
70715 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_PADDING_get() {
70716   int jresult ;
70717   int result;
70718
70719   result = (int)Dali::Toolkit::PushButton::Property::ICON_PADDING;
70720   jresult = (int)result;
70721   return jresult;
70722 }
70723
70724
70725 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton_Property() {
70726   void * jresult ;
70727   Dali::Toolkit::PushButton::Property *result = 0 ;
70728
70729   {
70730     try {
70731       result = (Dali::Toolkit::PushButton::Property *)new Dali::Toolkit::PushButton::Property();
70732     } catch (std::out_of_range& e) {
70733       {
70734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70735       };
70736     } catch (std::exception& e) {
70737       {
70738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70739       };
70740     } catch (Dali::DaliException e) {
70741       {
70742         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70743       };
70744     } catch (...) {
70745       {
70746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70747       };
70748     }
70749   }
70750
70751   jresult = (void *)result;
70752   return jresult;
70753 }
70754
70755
70756 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton_Property(void * jarg1) {
70757   Dali::Toolkit::PushButton::Property *arg1 = (Dali::Toolkit::PushButton::Property *) 0 ;
70758
70759   arg1 = (Dali::Toolkit::PushButton::Property *)jarg1;
70760   {
70761     try {
70762       delete arg1;
70763     } catch (std::out_of_range& e) {
70764       {
70765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70766       };
70767     } catch (std::exception& e) {
70768       {
70769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70770       };
70771     } catch (Dali::DaliException e) {
70772       {
70773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70774       };
70775     } catch (...) {
70776       {
70777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70778       };
70779     }
70780   }
70781
70782 }
70783
70784
70785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_0() {
70786   void * jresult ;
70787   Dali::Toolkit::PushButton *result = 0 ;
70788
70789   {
70790     try {
70791       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton();
70792     } catch (std::out_of_range& e) {
70793       {
70794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70795       };
70796     } catch (std::exception& e) {
70797       {
70798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70799       };
70800     } catch (Dali::DaliException e) {
70801       {
70802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70803       };
70804     } catch (...) {
70805       {
70806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70807       };
70808     }
70809   }
70810
70811   jresult = (void *)result;
70812   return jresult;
70813 }
70814
70815
70816 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_1(void * jarg1) {
70817   void * jresult ;
70818   Dali::Toolkit::PushButton *arg1 = 0 ;
70819   Dali::Toolkit::PushButton *result = 0 ;
70820
70821   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70822   if (!arg1) {
70823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
70824     return 0;
70825   }
70826   {
70827     try {
70828       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton((Dali::Toolkit::PushButton const &)*arg1);
70829     } catch (std::out_of_range& e) {
70830       {
70831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70832       };
70833     } catch (std::exception& e) {
70834       {
70835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70836       };
70837     } catch (Dali::DaliException e) {
70838       {
70839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70840       };
70841     } catch (...) {
70842       {
70843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70844       };
70845     }
70846   }
70847
70848   jresult = (void *)result;
70849   return jresult;
70850 }
70851
70852
70853 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_Assign(void * jarg1, void * jarg2) {
70854   void * jresult ;
70855   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70856   Dali::Toolkit::PushButton *arg2 = 0 ;
70857   Dali::Toolkit::PushButton *result = 0 ;
70858
70859   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70860   arg2 = (Dali::Toolkit::PushButton *)jarg2;
70861   if (!arg2) {
70862     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
70863     return 0;
70864   }
70865   {
70866     try {
70867       result = (Dali::Toolkit::PushButton *) &(arg1)->operator =((Dali::Toolkit::PushButton const &)*arg2);
70868     } catch (std::out_of_range& e) {
70869       {
70870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70871       };
70872     } catch (std::exception& e) {
70873       {
70874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70875       };
70876     } catch (Dali::DaliException e) {
70877       {
70878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70879       };
70880     } catch (...) {
70881       {
70882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70883       };
70884     }
70885   }
70886
70887   jresult = (void *)result;
70888   return jresult;
70889 }
70890
70891
70892 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton(void * jarg1) {
70893   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70894
70895   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70896   {
70897     try {
70898       delete arg1;
70899     } catch (std::out_of_range& e) {
70900       {
70901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70902       };
70903     } catch (std::exception& e) {
70904       {
70905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70906       };
70907     } catch (Dali::DaliException e) {
70908       {
70909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70910       };
70911     } catch (...) {
70912       {
70913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70914       };
70915     }
70916   }
70917
70918 }
70919
70920
70921 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_New() {
70922   void * jresult ;
70923   Dali::Toolkit::PushButton result;
70924
70925   {
70926     try {
70927       result = Dali::Toolkit::PushButton::New();
70928     } catch (std::out_of_range& e) {
70929       {
70930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70931       };
70932     } catch (std::exception& e) {
70933       {
70934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70935       };
70936     } catch (Dali::DaliException e) {
70937       {
70938         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70939       };
70940     } catch (...) {
70941       {
70942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70943       };
70944     }
70945   }
70946
70947   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
70948   return jresult;
70949 }
70950
70951
70952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_DownCast(void * jarg1) {
70953   void * jresult ;
70954   Dali::BaseHandle arg1 ;
70955   Dali::BaseHandle *argp1 ;
70956   Dali::Toolkit::PushButton result;
70957
70958   argp1 = (Dali::BaseHandle *)jarg1;
70959   if (!argp1) {
70960     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
70961     return 0;
70962   }
70963   arg1 = *argp1;
70964   {
70965     try {
70966       result = Dali::Toolkit::PushButton::DownCast(arg1);
70967     } catch (std::out_of_range& e) {
70968       {
70969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70970       };
70971     } catch (std::exception& e) {
70972       {
70973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70974       };
70975     } catch (Dali::DaliException e) {
70976       {
70977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70978       };
70979     } catch (...) {
70980       {
70981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70982       };
70983     }
70984   }
70985
70986   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
70987   return jresult;
70988 }
70989
70990
70991 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_0_0(void * jarg1, void * jarg2) {
70992   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70993   Dali::Image arg2 ;
70994   Dali::Image *argp2 ;
70995
70996   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70997   argp2 = (Dali::Image *)jarg2;
70998   if (!argp2) {
70999     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
71000     return ;
71001   }
71002   arg2 = *argp2;
71003   {
71004     try {
71005       (arg1)->SetButtonImage(arg2);
71006     } catch (std::out_of_range& e) {
71007       {
71008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71009       };
71010     } catch (std::exception& e) {
71011       {
71012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71013       };
71014     } catch (Dali::DaliException e) {
71015       {
71016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71017       };
71018     } catch (...) {
71019       {
71020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71021       };
71022     }
71023   }
71024
71025 }
71026
71027
71028 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_1(void * jarg1, void * jarg2) {
71029   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71030   Dali::Actor arg2 ;
71031   Dali::Actor *argp2 ;
71032
71033   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71034   argp2 = (Dali::Actor *)jarg2;
71035   if (!argp2) {
71036     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71037     return ;
71038   }
71039   arg2 = *argp2;
71040   {
71041     try {
71042       (arg1)->SetButtonImage(arg2);
71043     } catch (std::out_of_range& e) {
71044       {
71045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71046       };
71047     } catch (std::exception& e) {
71048       {
71049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71050       };
71051     } catch (Dali::DaliException e) {
71052       {
71053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71054       };
71055     } catch (...) {
71056       {
71057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71058       };
71059     }
71060   }
71061
71062 }
71063
71064
71065 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetBackgroundImage(void * jarg1, void * jarg2) {
71066   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71067   Dali::Actor arg2 ;
71068   Dali::Actor *argp2 ;
71069
71070   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71071   argp2 = (Dali::Actor *)jarg2;
71072   if (!argp2) {
71073     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71074     return ;
71075   }
71076   arg2 = *argp2;
71077   {
71078     try {
71079       (arg1)->SetBackgroundImage(arg2);
71080     } catch (std::out_of_range& e) {
71081       {
71082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71083       };
71084     } catch (std::exception& e) {
71085       {
71086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71087       };
71088     } catch (Dali::DaliException e) {
71089       {
71090         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71091       };
71092     } catch (...) {
71093       {
71094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71095       };
71096     }
71097   }
71098
71099 }
71100
71101
71102 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_0_0(void * jarg1, void * jarg2) {
71103   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71104   Dali::Image arg2 ;
71105   Dali::Image *argp2 ;
71106
71107   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71108   argp2 = (Dali::Image *)jarg2;
71109   if (!argp2) {
71110     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
71111     return ;
71112   }
71113   arg2 = *argp2;
71114   {
71115     try {
71116       (arg1)->SetSelectedImage(arg2);
71117     } catch (std::out_of_range& e) {
71118       {
71119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71120       };
71121     } catch (std::exception& e) {
71122       {
71123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71124       };
71125     } catch (Dali::DaliException e) {
71126       {
71127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71128       };
71129     } catch (...) {
71130       {
71131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71132       };
71133     }
71134   }
71135
71136 }
71137
71138
71139 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_1(void * jarg1, void * jarg2) {
71140   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71141   Dali::Actor arg2 ;
71142   Dali::Actor *argp2 ;
71143
71144   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71145   argp2 = (Dali::Actor *)jarg2;
71146   if (!argp2) {
71147     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71148     return ;
71149   }
71150   arg2 = *argp2;
71151   {
71152     try {
71153       (arg1)->SetSelectedImage(arg2);
71154     } catch (std::out_of_range& e) {
71155       {
71156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71157       };
71158     } catch (std::exception& e) {
71159       {
71160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71161       };
71162     } catch (Dali::DaliException e) {
71163       {
71164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71165       };
71166     } catch (...) {
71167       {
71168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71169       };
71170     }
71171   }
71172
71173 }
71174
71175
71176 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedBackgroundImage(void * jarg1, void * jarg2) {
71177   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71178   Dali::Actor arg2 ;
71179   Dali::Actor *argp2 ;
71180
71181   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71182   argp2 = (Dali::Actor *)jarg2;
71183   if (!argp2) {
71184     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71185     return ;
71186   }
71187   arg2 = *argp2;
71188   {
71189     try {
71190       (arg1)->SetSelectedBackgroundImage(arg2);
71191     } catch (std::out_of_range& e) {
71192       {
71193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71194       };
71195     } catch (std::exception& e) {
71196       {
71197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71198       };
71199     } catch (Dali::DaliException e) {
71200       {
71201         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71202       };
71203     } catch (...) {
71204       {
71205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71206       };
71207     }
71208   }
71209
71210 }
71211
71212
71213 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledBackgroundImage(void * jarg1, void * jarg2) {
71214   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71215   Dali::Actor arg2 ;
71216   Dali::Actor *argp2 ;
71217
71218   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71219   argp2 = (Dali::Actor *)jarg2;
71220   if (!argp2) {
71221     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71222     return ;
71223   }
71224   arg2 = *argp2;
71225   {
71226     try {
71227       (arg1)->SetDisabledBackgroundImage(arg2);
71228     } catch (std::out_of_range& e) {
71229       {
71230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71231       };
71232     } catch (std::exception& e) {
71233       {
71234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71235       };
71236     } catch (Dali::DaliException e) {
71237       {
71238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71239       };
71240     } catch (...) {
71241       {
71242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71243       };
71244     }
71245   }
71246
71247 }
71248
71249
71250 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledImage(void * jarg1, void * jarg2) {
71251   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71252   Dali::Actor arg2 ;
71253   Dali::Actor *argp2 ;
71254
71255   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71256   argp2 = (Dali::Actor *)jarg2;
71257   if (!argp2) {
71258     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71259     return ;
71260   }
71261   arg2 = *argp2;
71262   {
71263     try {
71264       (arg1)->SetDisabledImage(arg2);
71265     } catch (std::out_of_range& e) {
71266       {
71267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71268       };
71269     } catch (std::exception& e) {
71270       {
71271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71272       };
71273     } catch (Dali::DaliException e) {
71274       {
71275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71276       };
71277     } catch (...) {
71278       {
71279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71280       };
71281     }
71282   }
71283
71284 }
71285
71286
71287 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledSelectedImage(void * jarg1, void * jarg2) {
71288   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71289   Dali::Actor arg2 ;
71290   Dali::Actor *argp2 ;
71291
71292   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71293   argp2 = (Dali::Actor *)jarg2;
71294   if (!argp2) {
71295     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71296     return ;
71297   }
71298   arg2 = *argp2;
71299   {
71300     try {
71301       (arg1)->SetDisabledSelectedImage(arg2);
71302     } catch (std::out_of_range& e) {
71303       {
71304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71305       };
71306     } catch (std::exception& e) {
71307       {
71308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71309       };
71310     } catch (Dali::DaliException e) {
71311       {
71312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71313       };
71314     } catch (...) {
71315       {
71316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71317       };
71318     }
71319   }
71320
71321 }
71322
71323
71324 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_0() {
71325   void * jresult ;
71326   Dali::Toolkit::RadioButton *result = 0 ;
71327
71328   {
71329     try {
71330       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton();
71331     } catch (std::out_of_range& e) {
71332       {
71333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71334       };
71335     } catch (std::exception& e) {
71336       {
71337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71338       };
71339     } catch (Dali::DaliException e) {
71340       {
71341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71342       };
71343     } catch (...) {
71344       {
71345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71346       };
71347     }
71348   }
71349
71350   jresult = (void *)result;
71351   return jresult;
71352 }
71353
71354
71355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_1(void * jarg1) {
71356   void * jresult ;
71357   Dali::Toolkit::RadioButton *arg1 = 0 ;
71358   Dali::Toolkit::RadioButton *result = 0 ;
71359
71360   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
71361   if (!arg1) {
71362     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
71363     return 0;
71364   }
71365   {
71366     try {
71367       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton((Dali::Toolkit::RadioButton const &)*arg1);
71368     } catch (std::out_of_range& e) {
71369       {
71370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71371       };
71372     } catch (std::exception& e) {
71373       {
71374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71375       };
71376     } catch (Dali::DaliException e) {
71377       {
71378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71379       };
71380     } catch (...) {
71381       {
71382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71383       };
71384     }
71385   }
71386
71387   jresult = (void *)result;
71388   return jresult;
71389 }
71390
71391
71392 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_Assign(void * jarg1, void * jarg2) {
71393   void * jresult ;
71394   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
71395   Dali::Toolkit::RadioButton *arg2 = 0 ;
71396   Dali::Toolkit::RadioButton *result = 0 ;
71397
71398   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
71399   arg2 = (Dali::Toolkit::RadioButton *)jarg2;
71400   if (!arg2) {
71401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
71402     return 0;
71403   }
71404   {
71405     try {
71406       result = (Dali::Toolkit::RadioButton *) &(arg1)->operator =((Dali::Toolkit::RadioButton const &)*arg2);
71407     } catch (std::out_of_range& e) {
71408       {
71409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71410       };
71411     } catch (std::exception& e) {
71412       {
71413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71414       };
71415     } catch (Dali::DaliException e) {
71416       {
71417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71418       };
71419     } catch (...) {
71420       {
71421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71422       };
71423     }
71424   }
71425
71426   jresult = (void *)result;
71427   return jresult;
71428 }
71429
71430
71431 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RadioButton(void * jarg1) {
71432   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
71433
71434   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
71435   {
71436     try {
71437       delete arg1;
71438     } catch (std::out_of_range& e) {
71439       {
71440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71441       };
71442     } catch (std::exception& e) {
71443       {
71444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71445       };
71446     } catch (Dali::DaliException e) {
71447       {
71448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71449       };
71450     } catch (...) {
71451       {
71452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71453       };
71454     }
71455   }
71456
71457 }
71458
71459
71460 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_0() {
71461   void * jresult ;
71462   Dali::Toolkit::RadioButton result;
71463
71464   {
71465     try {
71466       result = Dali::Toolkit::RadioButton::New();
71467     } catch (std::out_of_range& e) {
71468       {
71469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71470       };
71471     } catch (std::exception& e) {
71472       {
71473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71474       };
71475     } catch (Dali::DaliException e) {
71476       {
71477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71478       };
71479     } catch (...) {
71480       {
71481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71482       };
71483     }
71484   }
71485
71486   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
71487   return jresult;
71488 }
71489
71490
71491 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_1(char * jarg1) {
71492   void * jresult ;
71493   std::string *arg1 = 0 ;
71494   Dali::Toolkit::RadioButton result;
71495
71496   if (!jarg1) {
71497     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
71498     return 0;
71499   }
71500   std::string arg1_str(jarg1);
71501   arg1 = &arg1_str;
71502   {
71503     try {
71504       result = Dali::Toolkit::RadioButton::New((std::string const &)*arg1);
71505     } catch (std::out_of_range& e) {
71506       {
71507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71508       };
71509     } catch (std::exception& e) {
71510       {
71511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71512       };
71513     } catch (Dali::DaliException e) {
71514       {
71515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71516       };
71517     } catch (...) {
71518       {
71519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71520       };
71521     }
71522   }
71523
71524   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
71525
71526   //argout typemap for const std::string&
71527
71528   return jresult;
71529 }
71530
71531
71532 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_DownCast(void * jarg1) {
71533   void * jresult ;
71534   Dali::BaseHandle arg1 ;
71535   Dali::BaseHandle *argp1 ;
71536   Dali::Toolkit::RadioButton result;
71537
71538   argp1 = (Dali::BaseHandle *)jarg1;
71539   if (!argp1) {
71540     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
71541     return 0;
71542   }
71543   arg1 = *argp1;
71544   {
71545     try {
71546       result = Dali::Toolkit::RadioButton::DownCast(arg1);
71547     } catch (std::out_of_range& e) {
71548       {
71549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71550       };
71551     } catch (std::exception& e) {
71552       {
71553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71554       };
71555     } catch (Dali::DaliException e) {
71556       {
71557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71558       };
71559     } catch (...) {
71560       {
71561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71562       };
71563     }
71564   }
71565
71566   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
71567   return jresult;
71568 }
71569
71570
71571 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_CONTENT_DIRECTION_get() {
71572   int jresult ;
71573   int result;
71574
71575   result = (int)Dali::Toolkit::FlexContainer::Property::CONTENT_DIRECTION;
71576   jresult = (int)result;
71577   return jresult;
71578 }
71579
71580
71581 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_DIRECTION_get() {
71582   int jresult ;
71583   int result;
71584
71585   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_DIRECTION;
71586   jresult = (int)result;
71587   return jresult;
71588 }
71589
71590
71591 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_WRAP_get() {
71592   int jresult ;
71593   int result;
71594
71595   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_WRAP;
71596   jresult = (int)result;
71597   return jresult;
71598 }
71599
71600
71601 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_JUSTIFY_CONTENT_get() {
71602   int jresult ;
71603   int result;
71604
71605   result = (int)Dali::Toolkit::FlexContainer::Property::JUSTIFY_CONTENT;
71606   jresult = (int)result;
71607   return jresult;
71608 }
71609
71610
71611 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_ITEMS_get() {
71612   int jresult ;
71613   int result;
71614
71615   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_ITEMS;
71616   jresult = (int)result;
71617   return jresult;
71618 }
71619
71620
71621 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_CONTENT_get() {
71622   int jresult ;
71623   int result;
71624
71625   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_CONTENT;
71626   jresult = (int)result;
71627   return jresult;
71628 }
71629
71630
71631 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_Property() {
71632   void * jresult ;
71633   Dali::Toolkit::FlexContainer::Property *result = 0 ;
71634
71635   {
71636     try {
71637       result = (Dali::Toolkit::FlexContainer::Property *)new Dali::Toolkit::FlexContainer::Property();
71638     } catch (std::out_of_range& e) {
71639       {
71640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71641       };
71642     } catch (std::exception& e) {
71643       {
71644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71645       };
71646     } catch (Dali::DaliException e) {
71647       {
71648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71649       };
71650     } catch (...) {
71651       {
71652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71653       };
71654     }
71655   }
71656
71657   jresult = (void *)result;
71658   return jresult;
71659 }
71660
71661
71662 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_Property(void * jarg1) {
71663   Dali::Toolkit::FlexContainer::Property *arg1 = (Dali::Toolkit::FlexContainer::Property *) 0 ;
71664
71665   arg1 = (Dali::Toolkit::FlexContainer::Property *)jarg1;
71666   {
71667     try {
71668       delete arg1;
71669     } catch (std::out_of_range& e) {
71670       {
71671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71672       };
71673     } catch (std::exception& e) {
71674       {
71675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71676       };
71677     } catch (Dali::DaliException e) {
71678       {
71679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71680       };
71681     } catch (...) {
71682       {
71683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71684       };
71685     }
71686   }
71687
71688 }
71689
71690
71691 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_get() {
71692   int jresult ;
71693   int result;
71694
71695   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX;
71696   jresult = (int)result;
71697   return jresult;
71698 }
71699
71700
71701 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_ALIGN_SELF_get() {
71702   int jresult ;
71703   int result;
71704
71705   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::ALIGN_SELF;
71706   jresult = (int)result;
71707   return jresult;
71708 }
71709
71710
71711 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_MARGIN_get() {
71712   int jresult ;
71713   int result;
71714
71715   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX_MARGIN;
71716   jresult = (int)result;
71717   return jresult;
71718 }
71719
71720
71721 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_ChildProperty() {
71722   void * jresult ;
71723   Dali::Toolkit::FlexContainer::ChildProperty *result = 0 ;
71724
71725   {
71726     try {
71727       result = (Dali::Toolkit::FlexContainer::ChildProperty *)new Dali::Toolkit::FlexContainer::ChildProperty();
71728     } catch (std::out_of_range& e) {
71729       {
71730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71731       };
71732     } catch (std::exception& e) {
71733       {
71734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71735       };
71736     } catch (Dali::DaliException e) {
71737       {
71738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71739       };
71740     } catch (...) {
71741       {
71742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71743       };
71744     }
71745   }
71746
71747   jresult = (void *)result;
71748   return jresult;
71749 }
71750
71751
71752 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_ChildProperty(void * jarg1) {
71753   Dali::Toolkit::FlexContainer::ChildProperty *arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *) 0 ;
71754
71755   arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *)jarg1;
71756   {
71757     try {
71758       delete arg1;
71759     } catch (std::out_of_range& e) {
71760       {
71761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71762       };
71763     } catch (std::exception& e) {
71764       {
71765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71766       };
71767     } catch (Dali::DaliException e) {
71768       {
71769         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71770       };
71771     } catch (...) {
71772       {
71773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71774       };
71775     }
71776   }
71777
71778 }
71779
71780
71781 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_0() {
71782   void * jresult ;
71783   Dali::Toolkit::FlexContainer *result = 0 ;
71784
71785   {
71786     try {
71787       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer();
71788     } catch (std::out_of_range& e) {
71789       {
71790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71791       };
71792     } catch (std::exception& e) {
71793       {
71794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71795       };
71796     } catch (Dali::DaliException e) {
71797       {
71798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71799       };
71800     } catch (...) {
71801       {
71802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71803       };
71804     }
71805   }
71806
71807   jresult = (void *)result;
71808   return jresult;
71809 }
71810
71811
71812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_1(void * jarg1) {
71813   void * jresult ;
71814   Dali::Toolkit::FlexContainer *arg1 = 0 ;
71815   Dali::Toolkit::FlexContainer *result = 0 ;
71816
71817   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
71818   if (!arg1) {
71819     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
71820     return 0;
71821   }
71822   {
71823     try {
71824       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer((Dali::Toolkit::FlexContainer const &)*arg1);
71825     } catch (std::out_of_range& e) {
71826       {
71827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71828       };
71829     } catch (std::exception& e) {
71830       {
71831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71832       };
71833     } catch (Dali::DaliException e) {
71834       {
71835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71836       };
71837     } catch (...) {
71838       {
71839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71840       };
71841     }
71842   }
71843
71844   jresult = (void *)result;
71845   return jresult;
71846 }
71847
71848
71849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_Assign(void * jarg1, void * jarg2) {
71850   void * jresult ;
71851   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
71852   Dali::Toolkit::FlexContainer *arg2 = 0 ;
71853   Dali::Toolkit::FlexContainer *result = 0 ;
71854
71855   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
71856   arg2 = (Dali::Toolkit::FlexContainer *)jarg2;
71857   if (!arg2) {
71858     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
71859     return 0;
71860   }
71861   {
71862     try {
71863       result = (Dali::Toolkit::FlexContainer *) &(arg1)->operator =((Dali::Toolkit::FlexContainer const &)*arg2);
71864     } catch (std::out_of_range& e) {
71865       {
71866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71867       };
71868     } catch (std::exception& e) {
71869       {
71870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71871       };
71872     } catch (Dali::DaliException e) {
71873       {
71874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71875       };
71876     } catch (...) {
71877       {
71878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71879       };
71880     }
71881   }
71882
71883   jresult = (void *)result;
71884   return jresult;
71885 }
71886
71887
71888 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer(void * jarg1) {
71889   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
71890
71891   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
71892   {
71893     try {
71894       delete arg1;
71895     } catch (std::out_of_range& e) {
71896       {
71897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71898       };
71899     } catch (std::exception& e) {
71900       {
71901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71902       };
71903     } catch (Dali::DaliException e) {
71904       {
71905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71906       };
71907     } catch (...) {
71908       {
71909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71910       };
71911     }
71912   }
71913
71914 }
71915
71916
71917 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_New() {
71918   void * jresult ;
71919   Dali::Toolkit::FlexContainer result;
71920
71921   {
71922     try {
71923       result = Dali::Toolkit::FlexContainer::New();
71924     } catch (std::out_of_range& e) {
71925       {
71926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71927       };
71928     } catch (std::exception& e) {
71929       {
71930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71931       };
71932     } catch (Dali::DaliException e) {
71933       {
71934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71935       };
71936     } catch (...) {
71937       {
71938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71939       };
71940     }
71941   }
71942
71943   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
71944   return jresult;
71945 }
71946
71947
71948 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_DownCast(void * jarg1) {
71949   void * jresult ;
71950   Dali::BaseHandle arg1 ;
71951   Dali::BaseHandle *argp1 ;
71952   Dali::Toolkit::FlexContainer result;
71953
71954   argp1 = (Dali::BaseHandle *)jarg1;
71955   if (!argp1) {
71956     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
71957     return 0;
71958   }
71959   arg1 = *argp1;
71960   {
71961     try {
71962       result = Dali::Toolkit::FlexContainer::DownCast(arg1);
71963     } catch (std::out_of_range& e) {
71964       {
71965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71966       };
71967     } catch (std::exception& e) {
71968       {
71969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71970       };
71971     } catch (Dali::DaliException e) {
71972       {
71973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71974       };
71975     } catch (...) {
71976       {
71977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71978       };
71979     }
71980   }
71981
71982   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
71983   return jresult;
71984 }
71985
71986
71987 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_RESOURCE_URL_get() {
71988   int jresult ;
71989   int result;
71990
71991   result = (int)Dali::Toolkit::ImageView::Property::RESOURCE_URL;
71992   jresult = (int)result;
71993   return jresult;
71994 }
71995
71996
71997 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_IMAGE_get() {
71998   int jresult ;
71999   int result;
72000
72001   result = (int)Dali::Toolkit::ImageView::Property::IMAGE;
72002   jresult = (int)result;
72003   return jresult;
72004 }
72005
72006
72007 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PRE_MULTIPLIED_ALPHA_get() {
72008   int jresult ;
72009   int result;
72010
72011   result = (int)Dali::Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA;
72012   jresult = (int)result;
72013   return jresult;
72014 }
72015
72016
72017 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PIXEL_AREA_get() {
72018   int jresult ;
72019   int result;
72020
72021   result = (int)Dali::Toolkit::ImageView::Property::PIXEL_AREA;
72022   jresult = (int)result;
72023   return jresult;
72024 }
72025
72026
72027 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView_Property() {
72028   void * jresult ;
72029   Dali::Toolkit::ImageView::Property *result = 0 ;
72030
72031   {
72032     try {
72033       result = (Dali::Toolkit::ImageView::Property *)new Dali::Toolkit::ImageView::Property();
72034     } catch (std::out_of_range& e) {
72035       {
72036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72037       };
72038     } catch (std::exception& e) {
72039       {
72040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72041       };
72042     } catch (Dali::DaliException e) {
72043       {
72044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72045       };
72046     } catch (...) {
72047       {
72048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72049       };
72050     }
72051   }
72052
72053   jresult = (void *)result;
72054   return jresult;
72055 }
72056
72057
72058 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView_Property(void * jarg1) {
72059   Dali::Toolkit::ImageView::Property *arg1 = (Dali::Toolkit::ImageView::Property *) 0 ;
72060
72061   arg1 = (Dali::Toolkit::ImageView::Property *)jarg1;
72062   {
72063     try {
72064       delete arg1;
72065     } catch (std::out_of_range& e) {
72066       {
72067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72068       };
72069     } catch (std::exception& e) {
72070       {
72071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72072       };
72073     } catch (Dali::DaliException e) {
72074       {
72075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72076       };
72077     } catch (...) {
72078       {
72079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72080       };
72081     }
72082   }
72083
72084 }
72085
72086
72087 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_0() {
72088   void * jresult ;
72089   Dali::Toolkit::ImageView *result = 0 ;
72090
72091   {
72092     try {
72093       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView();
72094     } catch (std::out_of_range& e) {
72095       {
72096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72097       };
72098     } catch (std::exception& e) {
72099       {
72100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72101       };
72102     } catch (Dali::DaliException e) {
72103       {
72104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72105       };
72106     } catch (...) {
72107       {
72108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72109       };
72110     }
72111   }
72112
72113   jresult = (void *)result;
72114   return jresult;
72115 }
72116
72117
72118 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_0() {
72119   void * jresult ;
72120   Dali::Toolkit::ImageView result;
72121
72122   {
72123     try {
72124       result = Dali::Toolkit::ImageView::New();
72125     } catch (std::out_of_range& e) {
72126       {
72127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72128       };
72129     } catch (std::exception& e) {
72130       {
72131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72132       };
72133     } catch (Dali::DaliException e) {
72134       {
72135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72136       };
72137     } catch (...) {
72138       {
72139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72140       };
72141     }
72142   }
72143
72144   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
72145   return jresult;
72146 }
72147
72148
72149 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_1(void * jarg1) {
72150   void * jresult ;
72151   Dali::Image arg1 ;
72152   Dali::Image *argp1 ;
72153   Dali::Toolkit::ImageView result;
72154
72155   argp1 = (Dali::Image *)jarg1;
72156   if (!argp1) {
72157     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
72158     return 0;
72159   }
72160   arg1 = *argp1;
72161   {
72162     try {
72163       result = Dali::Toolkit::ImageView::New(arg1);
72164     } catch (std::out_of_range& e) {
72165       {
72166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72167       };
72168     } catch (std::exception& e) {
72169       {
72170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72171       };
72172     } catch (Dali::DaliException e) {
72173       {
72174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72175       };
72176     } catch (...) {
72177       {
72178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72179       };
72180     }
72181   }
72182
72183   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
72184   return jresult;
72185 }
72186
72187
72188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_2(char * jarg1) {
72189   void * jresult ;
72190   std::string *arg1 = 0 ;
72191   Dali::Toolkit::ImageView result;
72192
72193   if (!jarg1) {
72194     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72195     return 0;
72196   }
72197   std::string arg1_str(jarg1);
72198   arg1 = &arg1_str;
72199   {
72200     try {
72201       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1);
72202     } catch (std::out_of_range& e) {
72203       {
72204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72205       };
72206     } catch (std::exception& e) {
72207       {
72208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72209       };
72210     } catch (Dali::DaliException e) {
72211       {
72212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72213       };
72214     } catch (...) {
72215       {
72216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72217       };
72218     }
72219   }
72220
72221   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
72222
72223   //argout typemap for const std::string&
72224
72225   return jresult;
72226 }
72227
72228
72229 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_3(char * jarg1, void * jarg2) {
72230   void * jresult ;
72231   std::string *arg1 = 0 ;
72232   Dali::ImageDimensions arg2 ;
72233   Dali::ImageDimensions *argp2 ;
72234   Dali::Toolkit::ImageView result;
72235
72236   if (!jarg1) {
72237     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72238     return 0;
72239   }
72240   std::string arg1_str(jarg1);
72241   arg1 = &arg1_str;
72242   argp2 = (Dali::ImageDimensions *)jarg2;
72243   if (!argp2) {
72244     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
72245     return 0;
72246   }
72247   arg2 = *argp2;
72248   {
72249     try {
72250       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1,arg2);
72251     } catch (std::out_of_range& e) {
72252       {
72253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72254       };
72255     } catch (std::exception& e) {
72256       {
72257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72258       };
72259     } catch (Dali::DaliException e) {
72260       {
72261         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72262       };
72263     } catch (...) {
72264       {
72265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72266       };
72267     }
72268   }
72269
72270   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
72271
72272   //argout typemap for const std::string&
72273
72274   return jresult;
72275 }
72276
72277
72278 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView(void * jarg1) {
72279   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72280
72281   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72282   {
72283     try {
72284       delete arg1;
72285     } catch (std::out_of_range& e) {
72286       {
72287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72288       };
72289     } catch (std::exception& e) {
72290       {
72291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72292       };
72293     } catch (Dali::DaliException e) {
72294       {
72295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72296       };
72297     } catch (...) {
72298       {
72299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72300       };
72301     }
72302   }
72303
72304 }
72305
72306
72307 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_1(void * jarg1) {
72308   void * jresult ;
72309   Dali::Toolkit::ImageView *arg1 = 0 ;
72310   Dali::Toolkit::ImageView *result = 0 ;
72311
72312   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72313   if (!arg1) {
72314     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
72315     return 0;
72316   }
72317   {
72318     try {
72319       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView((Dali::Toolkit::ImageView const &)*arg1);
72320     } catch (std::out_of_range& e) {
72321       {
72322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72323       };
72324     } catch (std::exception& e) {
72325       {
72326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72327       };
72328     } catch (Dali::DaliException e) {
72329       {
72330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72331       };
72332     } catch (...) {
72333       {
72334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72335       };
72336     }
72337   }
72338
72339   jresult = (void *)result;
72340   return jresult;
72341 }
72342
72343
72344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_Assign(void * jarg1, void * jarg2) {
72345   void * jresult ;
72346   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72347   Dali::Toolkit::ImageView *arg2 = 0 ;
72348   Dali::Toolkit::ImageView *result = 0 ;
72349
72350   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72351   arg2 = (Dali::Toolkit::ImageView *)jarg2;
72352   if (!arg2) {
72353     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
72354     return 0;
72355   }
72356   {
72357     try {
72358       result = (Dali::Toolkit::ImageView *) &(arg1)->operator =((Dali::Toolkit::ImageView const &)*arg2);
72359     } catch (std::out_of_range& e) {
72360       {
72361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72362       };
72363     } catch (std::exception& e) {
72364       {
72365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72366       };
72367     } catch (Dali::DaliException e) {
72368       {
72369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72370       };
72371     } catch (...) {
72372       {
72373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72374       };
72375     }
72376   }
72377
72378   jresult = (void *)result;
72379   return jresult;
72380 }
72381
72382
72383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_DownCast(void * jarg1) {
72384   void * jresult ;
72385   Dali::BaseHandle arg1 ;
72386   Dali::BaseHandle *argp1 ;
72387   Dali::Toolkit::ImageView result;
72388
72389   argp1 = (Dali::BaseHandle *)jarg1;
72390   if (!argp1) {
72391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
72392     return 0;
72393   }
72394   arg1 = *argp1;
72395   {
72396     try {
72397       result = Dali::Toolkit::ImageView::DownCast(arg1);
72398     } catch (std::out_of_range& e) {
72399       {
72400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72401       };
72402     } catch (std::exception& e) {
72403       {
72404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72405       };
72406     } catch (Dali::DaliException e) {
72407       {
72408         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72409       };
72410     } catch (...) {
72411       {
72412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72413       };
72414     }
72415   }
72416
72417   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
72418   return jresult;
72419 }
72420
72421
72422 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_0(void * jarg1, void * jarg2) {
72423   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72424   Dali::Image arg2 ;
72425   Dali::Image *argp2 ;
72426
72427   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72428   argp2 = (Dali::Image *)jarg2;
72429   if (!argp2) {
72430     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
72431     return ;
72432   }
72433   arg2 = *argp2;
72434   {
72435     try {
72436       (arg1)->SetImage(arg2);
72437     } catch (std::out_of_range& e) {
72438       {
72439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72440       };
72441     } catch (std::exception& e) {
72442       {
72443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72444       };
72445     } catch (Dali::DaliException e) {
72446       {
72447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72448       };
72449     } catch (...) {
72450       {
72451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72452       };
72453     }
72454   }
72455
72456 }
72457
72458
72459 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_1(void * jarg1, char * jarg2) {
72460   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72461   std::string *arg2 = 0 ;
72462
72463   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72464   if (!jarg2) {
72465     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72466     return ;
72467   }
72468   std::string arg2_str(jarg2);
72469   arg2 = &arg2_str;
72470   {
72471     try {
72472       (arg1)->SetImage((std::string const &)*arg2);
72473     } catch (std::out_of_range& e) {
72474       {
72475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72476       };
72477     } catch (std::exception& e) {
72478       {
72479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72480       };
72481     } catch (Dali::DaliException e) {
72482       {
72483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72484       };
72485     } catch (...) {
72486       {
72487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72488       };
72489     }
72490   }
72491
72492
72493   //argout typemap for const std::string&
72494
72495 }
72496
72497
72498 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
72499   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72500   std::string *arg2 = 0 ;
72501   Dali::ImageDimensions arg3 ;
72502   Dali::ImageDimensions *argp3 ;
72503
72504   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72505   if (!jarg2) {
72506     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72507     return ;
72508   }
72509   std::string arg2_str(jarg2);
72510   arg2 = &arg2_str;
72511   argp3 = (Dali::ImageDimensions *)jarg3;
72512   if (!argp3) {
72513     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
72514     return ;
72515   }
72516   arg3 = *argp3;
72517   {
72518     try {
72519       (arg1)->SetImage((std::string const &)*arg2,arg3);
72520     } catch (std::out_of_range& e) {
72521       {
72522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72523       };
72524     } catch (std::exception& e) {
72525       {
72526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72527       };
72528     } catch (Dali::DaliException e) {
72529       {
72530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72531       };
72532     } catch (...) {
72533       {
72534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72535       };
72536     }
72537   }
72538
72539
72540   //argout typemap for const std::string&
72541
72542 }
72543
72544 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_GetImage(void * jarg1) {
72545   void * jresult ;
72546   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72547   Dali::Image result;
72548
72549   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72550   {
72551     try {
72552       result = ((Dali::Toolkit::ImageView const *)arg1)->GetImage();
72553     } catch (std::out_of_range& e) {
72554       {
72555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72556       };
72557     } catch (std::exception& e) {
72558       {
72559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72560       };
72561     } catch (Dali::DaliException e) {
72562       {
72563         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72564       };
72565     } catch (...) {
72566       {
72567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72568       };
72569     }
72570   }
72571
72572   jresult = new Dali::Image((const Dali::Image &)result);
72573   return jresult;
72574 }
72575
72576
72577 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_GEOMETRY_URL_get() {
72578   int jresult ;
72579   int result;
72580
72581   result = (int)Dali::Toolkit::Model3dView::Property::GEOMETRY_URL;
72582   jresult = (int)result;
72583   return jresult;
72584 }
72585
72586
72587 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_MATERIAL_URL_get() {
72588   int jresult ;
72589   int result;
72590
72591   result = (int)Dali::Toolkit::Model3dView::Property::MATERIAL_URL;
72592   jresult = (int)result;
72593   return jresult;
72594 }
72595
72596
72597 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_IMAGES_URL_get() {
72598   int jresult ;
72599   int result;
72600
72601   result = (int)Dali::Toolkit::Model3dView::Property::IMAGES_URL;
72602   jresult = (int)result;
72603   return jresult;
72604 }
72605
72606
72607 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_ILLUMINATION_TYPE_get() {
72608   int jresult ;
72609   int result;
72610
72611   result = (int)Dali::Toolkit::Model3dView::Property::ILLUMINATION_TYPE;
72612   jresult = (int)result;
72613   return jresult;
72614 }
72615
72616
72617 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE0_URL_get() {
72618   int jresult ;
72619   int result;
72620
72621   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE0_URL;
72622   jresult = (int)result;
72623   return jresult;
72624 }
72625
72626
72627 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE1_URL_get() {
72628   int jresult ;
72629   int result;
72630
72631   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE1_URL;
72632   jresult = (int)result;
72633   return jresult;
72634 }
72635
72636
72637 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE2_URL_get() {
72638   int jresult ;
72639   int result;
72640
72641   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE2_URL;
72642   jresult = (int)result;
72643   return jresult;
72644 }
72645
72646
72647 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_LIGHT_POSITION_get() {
72648   int jresult ;
72649   int result;
72650
72651   result = (int)Dali::Toolkit::Model3dView::Property::LIGHT_POSITION;
72652   jresult = (int)result;
72653   return jresult;
72654 }
72655
72656
72657 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView_Property() {
72658   void * jresult ;
72659   Dali::Toolkit::Model3dView::Property *result = 0 ;
72660
72661   {
72662     try {
72663       result = (Dali::Toolkit::Model3dView::Property *)new Dali::Toolkit::Model3dView::Property();
72664     } catch (std::out_of_range& e) {
72665       {
72666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72667       };
72668     } catch (std::exception& e) {
72669       {
72670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72671       };
72672     } catch (Dali::DaliException e) {
72673       {
72674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72675       };
72676     } catch (...) {
72677       {
72678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72679       };
72680     }
72681   }
72682
72683   jresult = (void *)result;
72684   return jresult;
72685 }
72686
72687
72688 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView_Property(void * jarg1) {
72689   Dali::Toolkit::Model3dView::Property *arg1 = (Dali::Toolkit::Model3dView::Property *) 0 ;
72690
72691   arg1 = (Dali::Toolkit::Model3dView::Property *)jarg1;
72692   {
72693     try {
72694       delete arg1;
72695     } catch (std::out_of_range& e) {
72696       {
72697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72698       };
72699     } catch (std::exception& e) {
72700       {
72701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72702       };
72703     } catch (Dali::DaliException e) {
72704       {
72705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72706       };
72707     } catch (...) {
72708       {
72709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72710       };
72711     }
72712   }
72713
72714 }
72715
72716
72717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_0() {
72718   void * jresult ;
72719   Dali::Toolkit::Model3dView result;
72720
72721   {
72722     try {
72723       result = Dali::Toolkit::Model3dView::New();
72724     } catch (std::out_of_range& e) {
72725       {
72726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72727       };
72728     } catch (std::exception& e) {
72729       {
72730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72731       };
72732     } catch (Dali::DaliException e) {
72733       {
72734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72735       };
72736     } catch (...) {
72737       {
72738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72739       };
72740     }
72741   }
72742
72743   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
72744   return jresult;
72745 }
72746
72747
72748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_1(char * jarg1, char * jarg2, char * jarg3) {
72749   void * jresult ;
72750   std::string *arg1 = 0 ;
72751   std::string *arg2 = 0 ;
72752   std::string *arg3 = 0 ;
72753   Dali::Toolkit::Model3dView result;
72754
72755   if (!jarg1) {
72756     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72757     return 0;
72758   }
72759   std::string arg1_str(jarg1);
72760   arg1 = &arg1_str;
72761   if (!jarg2) {
72762     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72763     return 0;
72764   }
72765   std::string arg2_str(jarg2);
72766   arg2 = &arg2_str;
72767   if (!jarg3) {
72768     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72769     return 0;
72770   }
72771   std::string arg3_str(jarg3);
72772   arg3 = &arg3_str;
72773   {
72774     try {
72775       result = Dali::Toolkit::Model3dView::New((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3);
72776     } catch (std::out_of_range& e) {
72777       {
72778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72779       };
72780     } catch (std::exception& e) {
72781       {
72782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72783       };
72784     } catch (Dali::DaliException e) {
72785       {
72786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72787       };
72788     } catch (...) {
72789       {
72790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72791       };
72792     }
72793   }
72794
72795   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
72796
72797   //argout typemap for const std::string&
72798
72799
72800   //argout typemap for const std::string&
72801
72802
72803   //argout typemap for const std::string&
72804
72805   return jresult;
72806 }
72807
72808
72809 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_0() {
72810   void * jresult ;
72811   Dali::Toolkit::Model3dView *result = 0 ;
72812
72813   {
72814     try {
72815       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView();
72816     } catch (std::out_of_range& e) {
72817       {
72818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72819       };
72820     } catch (std::exception& e) {
72821       {
72822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72823       };
72824     } catch (Dali::DaliException e) {
72825       {
72826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72827       };
72828     } catch (...) {
72829       {
72830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72831       };
72832     }
72833   }
72834
72835   jresult = (void *)result;
72836   return jresult;
72837 }
72838
72839
72840 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView(void * jarg1) {
72841   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
72842
72843   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
72844   {
72845     try {
72846       delete arg1;
72847     } catch (std::out_of_range& e) {
72848       {
72849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72850       };
72851     } catch (std::exception& e) {
72852       {
72853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72854       };
72855     } catch (Dali::DaliException e) {
72856       {
72857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72858       };
72859     } catch (...) {
72860       {
72861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72862       };
72863     }
72864   }
72865
72866 }
72867
72868
72869 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_1(void * jarg1) {
72870   void * jresult ;
72871   Dali::Toolkit::Model3dView *arg1 = 0 ;
72872   Dali::Toolkit::Model3dView *result = 0 ;
72873
72874   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
72875   if (!arg1) {
72876     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
72877     return 0;
72878   }
72879   {
72880     try {
72881       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView((Dali::Toolkit::Model3dView const &)*arg1);
72882     } catch (std::out_of_range& e) {
72883       {
72884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72885       };
72886     } catch (std::exception& e) {
72887       {
72888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72889       };
72890     } catch (Dali::DaliException e) {
72891       {
72892         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72893       };
72894     } catch (...) {
72895       {
72896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72897       };
72898     }
72899   }
72900
72901   jresult = (void *)result;
72902   return jresult;
72903 }
72904
72905
72906 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_Assign(void * jarg1, void * jarg2) {
72907   void * jresult ;
72908   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
72909   Dali::Toolkit::Model3dView *arg2 = 0 ;
72910   Dali::Toolkit::Model3dView *result = 0 ;
72911
72912   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
72913   arg2 = (Dali::Toolkit::Model3dView *)jarg2;
72914   if (!arg2) {
72915     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
72916     return 0;
72917   }
72918   {
72919     try {
72920       result = (Dali::Toolkit::Model3dView *) &(arg1)->operator =((Dali::Toolkit::Model3dView const &)*arg2);
72921     } catch (std::out_of_range& e) {
72922       {
72923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72924       };
72925     } catch (std::exception& e) {
72926       {
72927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72928       };
72929     } catch (Dali::DaliException e) {
72930       {
72931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72932       };
72933     } catch (...) {
72934       {
72935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72936       };
72937     }
72938   }
72939
72940   jresult = (void *)result;
72941   return jresult;
72942 }
72943
72944
72945 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_DownCast(void * jarg1) {
72946   void * jresult ;
72947   Dali::BaseHandle arg1 ;
72948   Dali::BaseHandle *argp1 ;
72949   Dali::Toolkit::Model3dView result;
72950
72951   argp1 = (Dali::BaseHandle *)jarg1;
72952   if (!argp1) {
72953     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
72954     return 0;
72955   }
72956   arg1 = *argp1;
72957   {
72958     try {
72959       result = Dali::Toolkit::Model3dView::DownCast(arg1);
72960     } catch (std::out_of_range& e) {
72961       {
72962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72963       };
72964     } catch (std::exception& e) {
72965       {
72966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72967       };
72968     } catch (Dali::DaliException e) {
72969       {
72970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72971       };
72972     } catch (...) {
72973       {
72974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72975       };
72976     }
72977   }
72978
72979   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
72980   return jresult;
72981 }
72982
72983
72984 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_DIRECTION_get() {
72985   int jresult ;
72986   int result;
72987
72988   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_DIRECTION;
72989   jresult = (int)result;
72990   return jresult;
72991 }
72992
72993
72994 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HEIGHT_POLICY_get() {
72995   int jresult ;
72996   int result;
72997
72998   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HEIGHT_POLICY;
72999   jresult = (int)result;
73000   return jresult;
73001 }
73002
73003
73004 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_FIXED_HEIGHT_get() {
73005   int jresult ;
73006   int result;
73007
73008   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_FIXED_HEIGHT;
73009   jresult = (int)result;
73010   return jresult;
73011 }
73012
73013
73014 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_SHOW_DURATION_get() {
73015   int jresult ;
73016   int result;
73017
73018   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_SHOW_DURATION;
73019   jresult = (int)result;
73020   return jresult;
73021 }
73022
73023
73024 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HIDE_DURATION_get() {
73025   int jresult ;
73026   int result;
73027
73028   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HIDE_DURATION;
73029   jresult = (int)result;
73030   return jresult;
73031 }
73032
73033
73034 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_POSITION_INTERVALS_get() {
73035   int jresult ;
73036   int result;
73037
73038   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_POSITION_INTERVALS;
73039   jresult = (int)result;
73040   return jresult;
73041 }
73042
73043
73044 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_MINIMUM_HEIGHT_get() {
73045   int jresult ;
73046   int result;
73047
73048   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_MINIMUM_HEIGHT;
73049   jresult = (int)result;
73050   return jresult;
73051 }
73052
73053
73054 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_START_PADDING_get() {
73055   int jresult ;
73056   int result;
73057
73058   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_START_PADDING;
73059   jresult = (int)result;
73060   return jresult;
73061 }
73062
73063
73064 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_END_PADDING_get() {
73065   int jresult ;
73066   int result;
73067
73068   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_END_PADDING;
73069   jresult = (int)result;
73070   return jresult;
73071 }
73072
73073
73074 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar_Property() {
73075   void * jresult ;
73076   Dali::Toolkit::ScrollBar::Property *result = 0 ;
73077
73078   {
73079     try {
73080       result = (Dali::Toolkit::ScrollBar::Property *)new Dali::Toolkit::ScrollBar::Property();
73081     } catch (std::out_of_range& e) {
73082       {
73083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73084       };
73085     } catch (std::exception& e) {
73086       {
73087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73088       };
73089     } catch (Dali::DaliException e) {
73090       {
73091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73092       };
73093     } catch (...) {
73094       {
73095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73096       };
73097     }
73098   }
73099
73100   jresult = (void *)result;
73101   return jresult;
73102 }
73103
73104
73105 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar_Property(void * jarg1) {
73106   Dali::Toolkit::ScrollBar::Property *arg1 = (Dali::Toolkit::ScrollBar::Property *) 0 ;
73107
73108   arg1 = (Dali::Toolkit::ScrollBar::Property *)jarg1;
73109   {
73110     try {
73111       delete arg1;
73112     } catch (std::out_of_range& e) {
73113       {
73114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73115       };
73116     } catch (std::exception& e) {
73117       {
73118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73119       };
73120     } catch (Dali::DaliException e) {
73121       {
73122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73123       };
73124     } catch (...) {
73125       {
73126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73127       };
73128     }
73129   }
73130
73131 }
73132
73133
73134 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_0() {
73135   void * jresult ;
73136   Dali::Toolkit::ScrollBar *result = 0 ;
73137
73138   {
73139     try {
73140       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar();
73141     } catch (std::out_of_range& e) {
73142       {
73143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73144       };
73145     } catch (std::exception& e) {
73146       {
73147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73148       };
73149     } catch (Dali::DaliException e) {
73150       {
73151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73152       };
73153     } catch (...) {
73154       {
73155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73156       };
73157     }
73158   }
73159
73160   jresult = (void *)result;
73161   return jresult;
73162 }
73163
73164
73165 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_1(void * jarg1) {
73166   void * jresult ;
73167   Dali::Toolkit::ScrollBar *arg1 = 0 ;
73168   Dali::Toolkit::ScrollBar *result = 0 ;
73169
73170   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73171   if (!arg1) {
73172     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
73173     return 0;
73174   }
73175   {
73176     try {
73177       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar((Dali::Toolkit::ScrollBar const &)*arg1);
73178     } catch (std::out_of_range& e) {
73179       {
73180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73181       };
73182     } catch (std::exception& e) {
73183       {
73184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73185       };
73186     } catch (Dali::DaliException e) {
73187       {
73188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73189       };
73190     } catch (...) {
73191       {
73192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73193       };
73194     }
73195   }
73196
73197   jresult = (void *)result;
73198   return jresult;
73199 }
73200
73201
73202 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_Assign(void * jarg1, void * jarg2) {
73203   void * jresult ;
73204   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73205   Dali::Toolkit::ScrollBar *arg2 = 0 ;
73206   Dali::Toolkit::ScrollBar *result = 0 ;
73207
73208   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73209   arg2 = (Dali::Toolkit::ScrollBar *)jarg2;
73210   if (!arg2) {
73211     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
73212     return 0;
73213   }
73214   {
73215     try {
73216       result = (Dali::Toolkit::ScrollBar *) &(arg1)->operator =((Dali::Toolkit::ScrollBar const &)*arg2);
73217     } catch (std::out_of_range& e) {
73218       {
73219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73220       };
73221     } catch (std::exception& e) {
73222       {
73223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73224       };
73225     } catch (Dali::DaliException e) {
73226       {
73227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73228       };
73229     } catch (...) {
73230       {
73231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73232       };
73233     }
73234   }
73235
73236   jresult = (void *)result;
73237   return jresult;
73238 }
73239
73240
73241 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar(void * jarg1) {
73242   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73243
73244   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73245   {
73246     try {
73247       delete arg1;
73248     } catch (std::out_of_range& e) {
73249       {
73250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73251       };
73252     } catch (std::exception& e) {
73253       {
73254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73255       };
73256     } catch (Dali::DaliException e) {
73257       {
73258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73259       };
73260     } catch (...) {
73261       {
73262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73263       };
73264     }
73265   }
73266
73267 }
73268
73269
73270 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_0(int jarg1) {
73271   void * jresult ;
73272   Dali::Toolkit::ScrollBar::Direction arg1 ;
73273   Dali::Toolkit::ScrollBar result;
73274
73275   arg1 = (Dali::Toolkit::ScrollBar::Direction)jarg1;
73276   {
73277     try {
73278       result = Dali::Toolkit::ScrollBar::New(arg1);
73279     } catch (std::out_of_range& e) {
73280       {
73281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73282       };
73283     } catch (std::exception& e) {
73284       {
73285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73286       };
73287     } catch (Dali::DaliException e) {
73288       {
73289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73290       };
73291     } catch (...) {
73292       {
73293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73294       };
73295     }
73296   }
73297
73298   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
73299   return jresult;
73300 }
73301
73302
73303 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_1() {
73304   void * jresult ;
73305   Dali::Toolkit::ScrollBar result;
73306
73307   {
73308     try {
73309       result = Dali::Toolkit::ScrollBar::New();
73310     } catch (std::out_of_range& e) {
73311       {
73312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73313       };
73314     } catch (std::exception& e) {
73315       {
73316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73317       };
73318     } catch (Dali::DaliException e) {
73319       {
73320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73321       };
73322     } catch (...) {
73323       {
73324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73325       };
73326     }
73327   }
73328
73329   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
73330   return jresult;
73331 }
73332
73333
73334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_DownCast(void * jarg1) {
73335   void * jresult ;
73336   Dali::BaseHandle arg1 ;
73337   Dali::BaseHandle *argp1 ;
73338   Dali::Toolkit::ScrollBar result;
73339
73340   argp1 = (Dali::BaseHandle *)jarg1;
73341   if (!argp1) {
73342     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
73343     return 0;
73344   }
73345   arg1 = *argp1;
73346   {
73347     try {
73348       result = Dali::Toolkit::ScrollBar::DownCast(arg1);
73349     } catch (std::out_of_range& e) {
73350       {
73351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73352       };
73353     } catch (std::exception& e) {
73354       {
73355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73356       };
73357     } catch (Dali::DaliException e) {
73358       {
73359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73360       };
73361     } catch (...) {
73362       {
73363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73364       };
73365     }
73366   }
73367
73368   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
73369   return jresult;
73370 }
73371
73372
73373 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPropertySource(void * jarg1, void * jarg2, int jarg3, int jarg4, int jarg5, int jarg6) {
73374   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73375   Dali::Handle arg2 ;
73376   Dali::Property::Index arg3 ;
73377   Dali::Property::Index arg4 ;
73378   Dali::Property::Index arg5 ;
73379   Dali::Property::Index arg6 ;
73380   Dali::Handle *argp2 ;
73381
73382   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73383   argp2 = (Dali::Handle *)jarg2;
73384   if (!argp2) {
73385     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Handle", 0);
73386     return ;
73387   }
73388   arg2 = *argp2;
73389   arg3 = (Dali::Property::Index)jarg3;
73390   arg4 = (Dali::Property::Index)jarg4;
73391   arg5 = (Dali::Property::Index)jarg5;
73392   arg6 = (Dali::Property::Index)jarg6;
73393   {
73394     try {
73395       (arg1)->SetScrollPropertySource(arg2,arg3,arg4,arg5,arg6);
73396     } catch (std::out_of_range& e) {
73397       {
73398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73399       };
73400     } catch (std::exception& e) {
73401       {
73402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73403       };
73404     } catch (Dali::DaliException e) {
73405       {
73406         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73407       };
73408     } catch (...) {
73409       {
73410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73411       };
73412     }
73413   }
73414
73415 }
73416
73417
73418 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollIndicator(void * jarg1, void * jarg2) {
73419   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73420   Dali::Actor arg2 ;
73421   Dali::Actor *argp2 ;
73422
73423   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73424   argp2 = (Dali::Actor *)jarg2;
73425   if (!argp2) {
73426     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
73427     return ;
73428   }
73429   arg2 = *argp2;
73430   {
73431     try {
73432       (arg1)->SetScrollIndicator(arg2);
73433     } catch (std::out_of_range& e) {
73434       {
73435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73436       };
73437     } catch (std::exception& e) {
73438       {
73439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73440       };
73441     } catch (Dali::DaliException e) {
73442       {
73443         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73444       };
73445     } catch (...) {
73446       {
73447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73448       };
73449     }
73450   }
73451
73452 }
73453
73454
73455 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollIndicator(void * jarg1) {
73456   void * jresult ;
73457   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73458   Dali::Actor result;
73459
73460   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73461   {
73462     try {
73463       result = (arg1)->GetScrollIndicator();
73464     } catch (std::out_of_range& e) {
73465       {
73466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73467       };
73468     } catch (std::exception& e) {
73469       {
73470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73471       };
73472     } catch (Dali::DaliException e) {
73473       {
73474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73475       };
73476     } catch (...) {
73477       {
73478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73479       };
73480     }
73481   }
73482
73483   jresult = new Dali::Actor((const Dali::Actor &)result);
73484   return jresult;
73485 }
73486
73487
73488 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPositionIntervals(void * jarg1, void * jarg2) {
73489   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73490   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg2 = 0 ;
73491
73492   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73493   arg2 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg2;
73494   if (!arg2) {
73495     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
73496     return ;
73497   }
73498   {
73499     try {
73500       (arg1)->SetScrollPositionIntervals((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg2);
73501     } catch (std::out_of_range& e) {
73502       {
73503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73504       };
73505     } catch (std::exception& e) {
73506       {
73507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73508       };
73509     } catch (Dali::DaliException e) {
73510       {
73511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73512       };
73513     } catch (...) {
73514       {
73515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73516       };
73517     }
73518   }
73519
73520 }
73521
73522
73523 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollPositionIntervals(void * jarg1) {
73524   void * jresult ;
73525   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73526
73527   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73528   {
73529     try {
73530       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()));
73531     } catch (std::out_of_range& e) {
73532       {
73533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73534       };
73535     } catch (std::exception& e) {
73536       {
73537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73538       };
73539     } catch (...) {
73540       {
73541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73542       };
73543     }
73544   }
73545   return jresult;
73546 }
73547
73548
73549 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollDirection(void * jarg1, int jarg2) {
73550   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73551   Dali::Toolkit::ScrollBar::Direction arg2 ;
73552
73553   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73554   arg2 = (Dali::Toolkit::ScrollBar::Direction)jarg2;
73555   {
73556     try {
73557       (arg1)->SetScrollDirection(arg2);
73558     } catch (std::out_of_range& e) {
73559       {
73560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73561       };
73562     } catch (std::exception& e) {
73563       {
73564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73565       };
73566     } catch (Dali::DaliException e) {
73567       {
73568         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73569       };
73570     } catch (...) {
73571       {
73572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73573       };
73574     }
73575   }
73576
73577 }
73578
73579
73580 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollDirection(void * jarg1) {
73581   int jresult ;
73582   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73583   Dali::Toolkit::ScrollBar::Direction result;
73584
73585   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73586   {
73587     try {
73588       result = (Dali::Toolkit::ScrollBar::Direction)((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollDirection();
73589     } catch (std::out_of_range& e) {
73590       {
73591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73592       };
73593     } catch (std::exception& e) {
73594       {
73595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73596       };
73597     } catch (Dali::DaliException e) {
73598       {
73599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73600       };
73601     } catch (...) {
73602       {
73603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73604       };
73605     }
73606   }
73607
73608   jresult = (int)result;
73609   return jresult;
73610 }
73611
73612
73613 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHeightPolicy(void * jarg1, int jarg2) {
73614   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73615   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy arg2 ;
73616
73617   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73618   arg2 = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)jarg2;
73619   {
73620     try {
73621       (arg1)->SetIndicatorHeightPolicy(arg2);
73622     } catch (std::out_of_range& e) {
73623       {
73624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73625       };
73626     } catch (std::exception& e) {
73627       {
73628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73629       };
73630     } catch (Dali::DaliException e) {
73631       {
73632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73633       };
73634     } catch (...) {
73635       {
73636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73637       };
73638     }
73639   }
73640
73641 }
73642
73643
73644 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHeightPolicy(void * jarg1) {
73645   int jresult ;
73646   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73647   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy result;
73648
73649   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73650   {
73651     try {
73652       result = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHeightPolicy();
73653     } catch (std::out_of_range& e) {
73654       {
73655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73656       };
73657     } catch (std::exception& e) {
73658       {
73659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73660       };
73661     } catch (Dali::DaliException e) {
73662       {
73663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73664       };
73665     } catch (...) {
73666       {
73667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73668       };
73669     }
73670   }
73671
73672   jresult = (int)result;
73673   return jresult;
73674 }
73675
73676
73677 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorFixedHeight(void * jarg1, float jarg2) {
73678   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73679   float arg2 ;
73680
73681   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73682   arg2 = (float)jarg2;
73683   {
73684     try {
73685       (arg1)->SetIndicatorFixedHeight(arg2);
73686     } catch (std::out_of_range& e) {
73687       {
73688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73689       };
73690     } catch (std::exception& e) {
73691       {
73692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73693       };
73694     } catch (Dali::DaliException e) {
73695       {
73696         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73697       };
73698     } catch (...) {
73699       {
73700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73701       };
73702     }
73703   }
73704
73705 }
73706
73707
73708 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorFixedHeight(void * jarg1) {
73709   float jresult ;
73710   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73711   float result;
73712
73713   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73714   {
73715     try {
73716       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorFixedHeight();
73717     } catch (std::out_of_range& e) {
73718       {
73719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73720       };
73721     } catch (std::exception& e) {
73722       {
73723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73724       };
73725     } catch (Dali::DaliException e) {
73726       {
73727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73728       };
73729     } catch (...) {
73730       {
73731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73732       };
73733     }
73734   }
73735
73736   jresult = result;
73737   return jresult;
73738 }
73739
73740
73741 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorShowDuration(void * jarg1, float jarg2) {
73742   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73743   float arg2 ;
73744
73745   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73746   arg2 = (float)jarg2;
73747   {
73748     try {
73749       (arg1)->SetIndicatorShowDuration(arg2);
73750     } catch (std::out_of_range& e) {
73751       {
73752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73753       };
73754     } catch (std::exception& e) {
73755       {
73756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73757       };
73758     } catch (Dali::DaliException e) {
73759       {
73760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73761       };
73762     } catch (...) {
73763       {
73764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73765       };
73766     }
73767   }
73768
73769 }
73770
73771
73772 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorShowDuration(void * jarg1) {
73773   float jresult ;
73774   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73775   float result;
73776
73777   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73778   {
73779     try {
73780       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorShowDuration();
73781     } catch (std::out_of_range& e) {
73782       {
73783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73784       };
73785     } catch (std::exception& e) {
73786       {
73787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73788       };
73789     } catch (Dali::DaliException e) {
73790       {
73791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73792       };
73793     } catch (...) {
73794       {
73795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73796       };
73797     }
73798   }
73799
73800   jresult = result;
73801   return jresult;
73802 }
73803
73804
73805 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHideDuration(void * jarg1, float jarg2) {
73806   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73807   float arg2 ;
73808
73809   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73810   arg2 = (float)jarg2;
73811   {
73812     try {
73813       (arg1)->SetIndicatorHideDuration(arg2);
73814     } catch (std::out_of_range& e) {
73815       {
73816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73817       };
73818     } catch (std::exception& e) {
73819       {
73820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73821       };
73822     } catch (Dali::DaliException e) {
73823       {
73824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73825       };
73826     } catch (...) {
73827       {
73828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73829       };
73830     }
73831   }
73832
73833 }
73834
73835
73836 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHideDuration(void * jarg1) {
73837   float jresult ;
73838   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73839   float result;
73840
73841   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73842   {
73843     try {
73844       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHideDuration();
73845     } catch (std::out_of_range& e) {
73846       {
73847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73848       };
73849     } catch (std::exception& e) {
73850       {
73851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73852       };
73853     } catch (Dali::DaliException e) {
73854       {
73855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73856       };
73857     } catch (...) {
73858       {
73859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73860       };
73861     }
73862   }
73863
73864   jresult = result;
73865   return jresult;
73866 }
73867
73868
73869 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_ShowIndicator(void * jarg1) {
73870   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73871
73872   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73873   {
73874     try {
73875       (arg1)->ShowIndicator();
73876     } catch (std::out_of_range& e) {
73877       {
73878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73879       };
73880     } catch (std::exception& e) {
73881       {
73882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73883       };
73884     } catch (Dali::DaliException e) {
73885       {
73886         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73887       };
73888     } catch (...) {
73889       {
73890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73891       };
73892     }
73893   }
73894
73895 }
73896
73897
73898 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_HideIndicator(void * jarg1) {
73899   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73900
73901   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73902   {
73903     try {
73904       (arg1)->HideIndicator();
73905     } catch (std::out_of_range& e) {
73906       {
73907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73908       };
73909     } catch (std::exception& e) {
73910       {
73911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73912       };
73913     } catch (Dali::DaliException e) {
73914       {
73915         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73916       };
73917     } catch (...) {
73918       {
73919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73920       };
73921     }
73922   }
73923
73924 }
73925
73926
73927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_PanFinishedSignal(void * jarg1) {
73928   void * jresult ;
73929   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73930   Dali::Toolkit::ScrollBar::PanFinishedSignalType *result = 0 ;
73931
73932   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73933   {
73934     try {
73935       result = (Dali::Toolkit::ScrollBar::PanFinishedSignalType *) &(arg1)->PanFinishedSignal();
73936     } catch (std::out_of_range& e) {
73937       {
73938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73939       };
73940     } catch (std::exception& e) {
73941       {
73942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73943       };
73944     } catch (Dali::DaliException e) {
73945       {
73946         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73947       };
73948     } catch (...) {
73949       {
73950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73951       };
73952     }
73953   }
73954
73955   jresult = (void *)result;
73956   return jresult;
73957 }
73958
73959
73960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_ScrollPositionIntervalReachedSignal(void * jarg1) {
73961   void * jresult ;
73962   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73963   Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *result = 0 ;
73964
73965   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73966   {
73967     try {
73968       result = (Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *) &(arg1)->ScrollPositionIntervalReachedSignal();
73969     } catch (std::out_of_range& e) {
73970       {
73971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73972       };
73973     } catch (std::exception& e) {
73974       {
73975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73976       };
73977     } catch (Dali::DaliException e) {
73978       {
73979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73980       };
73981     } catch (...) {
73982       {
73983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73984       };
73985     }
73986   }
73987
73988   jresult = (void *)result;
73989   return jresult;
73990 }
73991
73992
73993 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_EFFECT_COLOR_get() {
73994   int jresult ;
73995   int result;
73996
73997   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_EFFECT_COLOR;
73998   jresult = (int)result;
73999   return jresult;
74000 }
74001
74002
74003 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ANIMATION_SPEED_get() {
74004   int jresult ;
74005   int result;
74006
74007   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ANIMATION_SPEED;
74008   jresult = (int)result;
74009   return jresult;
74010 }
74011
74012
74013 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ENABLED_get() {
74014   int jresult ;
74015   int result;
74016
74017   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ENABLED;
74018   jresult = (int)result;
74019   return jresult;
74020 }
74021
74022
74023 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_SIZE_get() {
74024   int jresult ;
74025   int result;
74026
74027   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_SIZE;
74028   jresult = (int)result;
74029   return jresult;
74030 }
74031
74032
74033 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_TO_ALPHA_FUNCTION_get() {
74034   int jresult ;
74035   int result;
74036
74037   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_TO_ALPHA_FUNCTION;
74038   jresult = (int)result;
74039   return jresult;
74040 }
74041
74042
74043 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_RELATIVE_POSITION_get() {
74044   int jresult ;
74045   int result;
74046
74047   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_RELATIVE_POSITION;
74048   jresult = (int)result;
74049   return jresult;
74050 }
74051
74052
74053 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_get() {
74054   int jresult ;
74055   int result;
74056
74057   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN;
74058   jresult = (int)result;
74059   return jresult;
74060 }
74061
74062
74063 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_X_get() {
74064   int jresult ;
74065   int result;
74066
74067   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_X;
74068   jresult = (int)result;
74069   return jresult;
74070 }
74071
74072
74073 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_Y_get() {
74074   int jresult ;
74075   int result;
74076
74077   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_Y;
74078   jresult = (int)result;
74079   return jresult;
74080 }
74081
74082
74083 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_get() {
74084   int jresult ;
74085   int result;
74086
74087   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX;
74088   jresult = (int)result;
74089   return jresult;
74090 }
74091
74092
74093 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_X_get() {
74094   int jresult ;
74095   int result;
74096
74097   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_X;
74098   jresult = (int)result;
74099   return jresult;
74100 }
74101
74102
74103 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_Y_get() {
74104   int jresult ;
74105   int result;
74106
74107   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_Y;
74108   jresult = (int)result;
74109   return jresult;
74110 }
74111
74112
74113 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_VERTICAL_get() {
74114   int jresult ;
74115   int result;
74116
74117   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_VERTICAL;
74118   jresult = (int)result;
74119   return jresult;
74120 }
74121
74122
74123 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_HORIZONTAL_get() {
74124   int jresult ;
74125   int result;
74126
74127   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_HORIZONTAL;
74128   jresult = (int)result;
74129   return jresult;
74130 }
74131
74132
74133 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable_Property() {
74134   void * jresult ;
74135   Dali::Toolkit::Scrollable::Property *result = 0 ;
74136
74137   {
74138     try {
74139       result = (Dali::Toolkit::Scrollable::Property *)new Dali::Toolkit::Scrollable::Property();
74140     } catch (std::out_of_range& e) {
74141       {
74142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74143       };
74144     } catch (std::exception& e) {
74145       {
74146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74147       };
74148     } catch (Dali::DaliException e) {
74149       {
74150         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74151       };
74152     } catch (...) {
74153       {
74154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74155       };
74156     }
74157   }
74158
74159   jresult = (void *)result;
74160   return jresult;
74161 }
74162
74163
74164 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable_Property(void * jarg1) {
74165   Dali::Toolkit::Scrollable::Property *arg1 = (Dali::Toolkit::Scrollable::Property *) 0 ;
74166
74167   arg1 = (Dali::Toolkit::Scrollable::Property *)jarg1;
74168   {
74169     try {
74170       delete arg1;
74171     } catch (std::out_of_range& e) {
74172       {
74173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74174       };
74175     } catch (std::exception& e) {
74176       {
74177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74178       };
74179     } catch (Dali::DaliException e) {
74180       {
74181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74182       };
74183     } catch (...) {
74184       {
74185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74186       };
74187     }
74188   }
74189
74190 }
74191
74192
74193 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_0() {
74194   void * jresult ;
74195   Dali::Toolkit::Scrollable *result = 0 ;
74196
74197   {
74198     try {
74199       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable();
74200     } catch (std::out_of_range& e) {
74201       {
74202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74203       };
74204     } catch (std::exception& e) {
74205       {
74206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74207       };
74208     } catch (Dali::DaliException e) {
74209       {
74210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74211       };
74212     } catch (...) {
74213       {
74214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74215       };
74216     }
74217   }
74218
74219   jresult = (void *)result;
74220   return jresult;
74221 }
74222
74223
74224 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_1(void * jarg1) {
74225   void * jresult ;
74226   Dali::Toolkit::Scrollable *arg1 = 0 ;
74227   Dali::Toolkit::Scrollable *result = 0 ;
74228
74229   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74230   if (!arg1) {
74231     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
74232     return 0;
74233   }
74234   {
74235     try {
74236       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable((Dali::Toolkit::Scrollable const &)*arg1);
74237     } catch (std::out_of_range& e) {
74238       {
74239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74240       };
74241     } catch (std::exception& e) {
74242       {
74243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74244       };
74245     } catch (Dali::DaliException e) {
74246       {
74247         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74248       };
74249     } catch (...) {
74250       {
74251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74252       };
74253     }
74254   }
74255
74256   jresult = (void *)result;
74257   return jresult;
74258 }
74259
74260
74261 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_Assign(void * jarg1, void * jarg2) {
74262   void * jresult ;
74263   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74264   Dali::Toolkit::Scrollable *arg2 = 0 ;
74265   Dali::Toolkit::Scrollable *result = 0 ;
74266
74267   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74268   arg2 = (Dali::Toolkit::Scrollable *)jarg2;
74269   if (!arg2) {
74270     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
74271     return 0;
74272   }
74273   {
74274     try {
74275       result = (Dali::Toolkit::Scrollable *) &(arg1)->operator =((Dali::Toolkit::Scrollable const &)*arg2);
74276     } catch (std::out_of_range& e) {
74277       {
74278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74279       };
74280     } catch (std::exception& e) {
74281       {
74282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74283       };
74284     } catch (Dali::DaliException e) {
74285       {
74286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74287       };
74288     } catch (...) {
74289       {
74290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74291       };
74292     }
74293   }
74294
74295   jresult = (void *)result;
74296   return jresult;
74297 }
74298
74299
74300 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable(void * jarg1) {
74301   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74302
74303   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74304   {
74305     try {
74306       delete arg1;
74307     } catch (std::out_of_range& e) {
74308       {
74309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74310       };
74311     } catch (std::exception& e) {
74312       {
74313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74314       };
74315     } catch (Dali::DaliException e) {
74316       {
74317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74318       };
74319     } catch (...) {
74320       {
74321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74322       };
74323     }
74324   }
74325
74326 }
74327
74328
74329 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_DownCast(void * jarg1) {
74330   void * jresult ;
74331   Dali::BaseHandle arg1 ;
74332   Dali::BaseHandle *argp1 ;
74333   Dali::Toolkit::Scrollable result;
74334
74335   argp1 = (Dali::BaseHandle *)jarg1;
74336   if (!argp1) {
74337     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
74338     return 0;
74339   }
74340   arg1 = *argp1;
74341   {
74342     try {
74343       result = Dali::Toolkit::Scrollable::DownCast(arg1);
74344     } catch (std::out_of_range& e) {
74345       {
74346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74347       };
74348     } catch (std::exception& e) {
74349       {
74350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74351       };
74352     } catch (Dali::DaliException e) {
74353       {
74354         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74355       };
74356     } catch (...) {
74357       {
74358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74359       };
74360     }
74361   }
74362
74363   jresult = new Dali::Toolkit::Scrollable((const Dali::Toolkit::Scrollable &)result);
74364   return jresult;
74365 }
74366
74367
74368 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Scrollable_IsOvershootEnabled(void * jarg1) {
74369   unsigned int jresult ;
74370   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74371   bool result;
74372
74373   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74374   {
74375     try {
74376       result = (bool)((Dali::Toolkit::Scrollable const *)arg1)->IsOvershootEnabled();
74377     } catch (std::out_of_range& e) {
74378       {
74379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74380       };
74381     } catch (std::exception& e) {
74382       {
74383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74384       };
74385     } catch (Dali::DaliException e) {
74386       {
74387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74388       };
74389     } catch (...) {
74390       {
74391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74392       };
74393     }
74394   }
74395
74396   jresult = result;
74397   return jresult;
74398 }
74399
74400
74401 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEnabled(void * jarg1, unsigned int jarg2) {
74402   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74403   bool arg2 ;
74404
74405   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74406   arg2 = jarg2 ? true : false;
74407   {
74408     try {
74409       (arg1)->SetOvershootEnabled(arg2);
74410     } catch (std::out_of_range& e) {
74411       {
74412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74413       };
74414     } catch (std::exception& e) {
74415       {
74416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74417       };
74418     } catch (Dali::DaliException e) {
74419       {
74420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74421       };
74422     } catch (...) {
74423       {
74424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74425       };
74426     }
74427   }
74428
74429 }
74430
74431
74432 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEffectColor(void * jarg1, void * jarg2) {
74433   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74434   Dali::Vector4 *arg2 = 0 ;
74435
74436   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74437   arg2 = (Dali::Vector4 *)jarg2;
74438   if (!arg2) {
74439     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
74440     return ;
74441   }
74442   {
74443     try {
74444       (arg1)->SetOvershootEffectColor((Dali::Vector4 const &)*arg2);
74445     } catch (std::out_of_range& e) {
74446       {
74447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74448       };
74449     } catch (std::exception& e) {
74450       {
74451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74452       };
74453     } catch (Dali::DaliException e) {
74454       {
74455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74456       };
74457     } catch (...) {
74458       {
74459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74460       };
74461     }
74462   }
74463
74464 }
74465
74466
74467 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootEffectColor(void * jarg1) {
74468   void * jresult ;
74469   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74470   Dali::Vector4 result;
74471
74472   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74473   {
74474     try {
74475       result = ((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootEffectColor();
74476     } catch (std::out_of_range& e) {
74477       {
74478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74479       };
74480     } catch (std::exception& e) {
74481       {
74482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74483       };
74484     } catch (Dali::DaliException e) {
74485       {
74486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74487       };
74488     } catch (...) {
74489       {
74490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74491       };
74492     }
74493   }
74494
74495   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
74496   return jresult;
74497 }
74498
74499
74500 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootAnimationSpeed(void * jarg1, float jarg2) {
74501   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74502   float arg2 ;
74503
74504   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74505   arg2 = (float)jarg2;
74506   {
74507     try {
74508       (arg1)->SetOvershootAnimationSpeed(arg2);
74509     } catch (std::out_of_range& e) {
74510       {
74511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74512       };
74513     } catch (std::exception& e) {
74514       {
74515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74516       };
74517     } catch (Dali::DaliException e) {
74518       {
74519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74520       };
74521     } catch (...) {
74522       {
74523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74524       };
74525     }
74526   }
74527
74528 }
74529
74530
74531 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootAnimationSpeed(void * jarg1) {
74532   float jresult ;
74533   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74534   float result;
74535
74536   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74537   {
74538     try {
74539       result = (float)((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootAnimationSpeed();
74540     } catch (std::out_of_range& e) {
74541       {
74542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74543       };
74544     } catch (std::exception& e) {
74545       {
74546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74547       };
74548     } catch (Dali::DaliException e) {
74549       {
74550         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74551       };
74552     } catch (...) {
74553       {
74554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74555       };
74556     }
74557   }
74558
74559   jresult = result;
74560   return jresult;
74561 }
74562
74563
74564 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollStartedSignal(void * jarg1) {
74565   void * jresult ;
74566   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74567   Dali::Toolkit::Scrollable::ScrollStartedSignalType *result = 0 ;
74568
74569   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74570   {
74571     try {
74572       result = (Dali::Toolkit::Scrollable::ScrollStartedSignalType *) &(arg1)->ScrollStartedSignal();
74573     } catch (std::out_of_range& e) {
74574       {
74575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74576       };
74577     } catch (std::exception& e) {
74578       {
74579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74580       };
74581     } catch (Dali::DaliException e) {
74582       {
74583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74584       };
74585     } catch (...) {
74586       {
74587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74588       };
74589     }
74590   }
74591
74592   jresult = (void *)result;
74593   return jresult;
74594 }
74595
74596
74597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollUpdatedSignal(void * jarg1) {
74598   void * jresult ;
74599   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74600   Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *result = 0 ;
74601
74602   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74603   {
74604     try {
74605       result = (Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *) &(arg1)->ScrollUpdatedSignal();
74606     } catch (std::out_of_range& e) {
74607       {
74608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74609       };
74610     } catch (std::exception& e) {
74611       {
74612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74613       };
74614     } catch (Dali::DaliException e) {
74615       {
74616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74617       };
74618     } catch (...) {
74619       {
74620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74621       };
74622     }
74623   }
74624
74625   jresult = (void *)result;
74626   return jresult;
74627 }
74628
74629
74630 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollCompletedSignal(void * jarg1) {
74631   void * jresult ;
74632   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74633   Dali::Toolkit::Scrollable::ScrollCompletedSignalType *result = 0 ;
74634
74635   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74636   {
74637     try {
74638       result = (Dali::Toolkit::Scrollable::ScrollCompletedSignalType *) &(arg1)->ScrollCompletedSignal();
74639     } catch (std::out_of_range& e) {
74640       {
74641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74642       };
74643     } catch (std::exception& e) {
74644       {
74645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74646       };
74647     } catch (Dali::DaliException e) {
74648       {
74649         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74650       };
74651     } catch (...) {
74652       {
74653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74654       };
74655     }
74656   }
74657
74658   jresult = (void *)result;
74659   return jresult;
74660 }
74661
74662
74663 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsVertical(int jarg1) {
74664   unsigned int jresult ;
74665   Dali::Toolkit::ControlOrientation::Type arg1 ;
74666   bool result;
74667
74668   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
74669   {
74670     try {
74671       result = (bool)Dali::Toolkit::IsVertical(arg1);
74672     } catch (std::out_of_range& e) {
74673       {
74674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74675       };
74676     } catch (std::exception& e) {
74677       {
74678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74679       };
74680     } catch (Dali::DaliException e) {
74681       {
74682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74683       };
74684     } catch (...) {
74685       {
74686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74687       };
74688     }
74689   }
74690
74691   jresult = result;
74692   return jresult;
74693 }
74694
74695
74696 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsHorizontal(int jarg1) {
74697   unsigned int jresult ;
74698   Dali::Toolkit::ControlOrientation::Type arg1 ;
74699   bool result;
74700
74701   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
74702   {
74703     try {
74704       result = (bool)Dali::Toolkit::IsHorizontal(arg1);
74705     } catch (std::out_of_range& e) {
74706       {
74707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74708       };
74709     } catch (std::exception& e) {
74710       {
74711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74712       };
74713     } catch (Dali::DaliException e) {
74714       {
74715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74716       };
74717     } catch (...) {
74718       {
74719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74720       };
74721     }
74722   }
74723
74724   jresult = result;
74725   return jresult;
74726 }
74727
74728
74729 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_0(unsigned int jarg1, unsigned int jarg2) {
74730   void * jresult ;
74731   unsigned int arg1 ;
74732   unsigned int arg2 ;
74733   Dali::Toolkit::ItemRange *result = 0 ;
74734
74735   arg1 = (unsigned int)jarg1;
74736   arg2 = (unsigned int)jarg2;
74737   {
74738     try {
74739       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange(arg1,arg2);
74740     } catch (std::out_of_range& e) {
74741       {
74742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74743       };
74744     } catch (std::exception& e) {
74745       {
74746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74747       };
74748     } catch (Dali::DaliException e) {
74749       {
74750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74751       };
74752     } catch (...) {
74753       {
74754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74755       };
74756     }
74757   }
74758
74759   jresult = (void *)result;
74760   return jresult;
74761 }
74762
74763
74764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_1(void * jarg1) {
74765   void * jresult ;
74766   Dali::Toolkit::ItemRange *arg1 = 0 ;
74767   Dali::Toolkit::ItemRange *result = 0 ;
74768
74769   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74770   if (!arg1) {
74771     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
74772     return 0;
74773   }
74774   {
74775     try {
74776       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange((Dali::Toolkit::ItemRange const &)*arg1);
74777     } catch (std::out_of_range& e) {
74778       {
74779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74780       };
74781     } catch (std::exception& e) {
74782       {
74783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74784       };
74785     } catch (Dali::DaliException e) {
74786       {
74787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74788       };
74789     } catch (...) {
74790       {
74791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74792       };
74793     }
74794   }
74795
74796   jresult = (void *)result;
74797   return jresult;
74798 }
74799
74800
74801 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Assign(void * jarg1, void * jarg2) {
74802   void * jresult ;
74803   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74804   Dali::Toolkit::ItemRange *arg2 = 0 ;
74805   Dali::Toolkit::ItemRange *result = 0 ;
74806
74807   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74808   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
74809   if (!arg2) {
74810     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
74811     return 0;
74812   }
74813   {
74814     try {
74815       result = (Dali::Toolkit::ItemRange *) &(arg1)->operator =((Dali::Toolkit::ItemRange const &)*arg2);
74816     } catch (std::out_of_range& e) {
74817       {
74818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74819       };
74820     } catch (std::exception& e) {
74821       {
74822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74823       };
74824     } catch (Dali::DaliException e) {
74825       {
74826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74827       };
74828     } catch (...) {
74829       {
74830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74831       };
74832     }
74833   }
74834
74835   jresult = (void *)result;
74836   return jresult;
74837 }
74838
74839
74840 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_Within(void * jarg1, unsigned int jarg2) {
74841   unsigned int jresult ;
74842   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74843   unsigned int arg2 ;
74844   bool result;
74845
74846   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74847   arg2 = (unsigned int)jarg2;
74848   {
74849     try {
74850       result = (bool)(arg1)->Within(arg2);
74851     } catch (std::out_of_range& e) {
74852       {
74853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74854       };
74855     } catch (std::exception& e) {
74856       {
74857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74858       };
74859     } catch (Dali::DaliException e) {
74860       {
74861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74862       };
74863     } catch (...) {
74864       {
74865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74866       };
74867     }
74868   }
74869
74870   jresult = result;
74871   return jresult;
74872 }
74873
74874
74875 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Intersection(void * jarg1, void * jarg2) {
74876   void * jresult ;
74877   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74878   Dali::Toolkit::ItemRange *arg2 = 0 ;
74879   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
74880
74881   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74882   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
74883   if (!arg2) {
74884     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
74885     return 0;
74886   }
74887   {
74888     try {
74889       result = (arg1)->Intersection((Dali::Toolkit::ItemRange const &)*arg2);
74890     } catch (std::out_of_range& e) {
74891       {
74892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74893       };
74894     } catch (std::exception& e) {
74895       {
74896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74897       };
74898     } catch (Dali::DaliException e) {
74899       {
74900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74901       };
74902     } catch (...) {
74903       {
74904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74905       };
74906     }
74907   }
74908
74909   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
74910   return jresult;
74911 }
74912
74913
74914 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_begin_set(void * jarg1, unsigned int jarg2) {
74915   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74916   unsigned int arg2 ;
74917
74918   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74919   arg2 = (unsigned int)jarg2;
74920   if (arg1) (arg1)->begin = arg2;
74921 }
74922
74923
74924 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_begin_get(void * jarg1) {
74925   unsigned int jresult ;
74926   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74927   unsigned int result;
74928
74929   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74930   result = (unsigned int) ((arg1)->begin);
74931   jresult = result;
74932   return jresult;
74933 }
74934
74935
74936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_end_set(void * jarg1, unsigned int jarg2) {
74937   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74938   unsigned int arg2 ;
74939
74940   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74941   arg2 = (unsigned int)jarg2;
74942   if (arg1) (arg1)->end = arg2;
74943 }
74944
74945
74946 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_end_get(void * jarg1) {
74947   unsigned int jresult ;
74948   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74949   unsigned int result;
74950
74951   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74952   result = (unsigned int) ((arg1)->end);
74953   jresult = result;
74954   return jresult;
74955 }
74956
74957
74958 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemRange(void * jarg1) {
74959   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74960
74961   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74962   {
74963     try {
74964       delete arg1;
74965     } catch (std::out_of_range& e) {
74966       {
74967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74968       };
74969     } catch (std::exception& e) {
74970       {
74971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74972       };
74973     } catch (Dali::DaliException e) {
74974       {
74975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74976       };
74977     } catch (...) {
74978       {
74979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74980       };
74981     }
74982   }
74983
74984 }
74985
74986
74987 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemLayout(void * jarg1) {
74988   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74989
74990   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74991   {
74992     try {
74993       delete arg1;
74994     } catch (std::out_of_range& e) {
74995       {
74996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74997       };
74998     } catch (std::exception& e) {
74999       {
75000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75001       };
75002     } catch (Dali::DaliException e) {
75003       {
75004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75005       };
75006     } catch (...) {
75007       {
75008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75009       };
75010     }
75011   }
75012
75013 }
75014
75015
75016 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetOrientation(void * jarg1, int jarg2) {
75017   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75018   Dali::Toolkit::ControlOrientation::Type arg2 ;
75019
75020   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75021   arg2 = (Dali::Toolkit::ControlOrientation::Type)jarg2;
75022   {
75023     try {
75024       (arg1)->SetOrientation(arg2);
75025     } catch (std::out_of_range& e) {
75026       {
75027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75028       };
75029     } catch (std::exception& e) {
75030       {
75031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75032       };
75033     } catch (Dali::DaliException e) {
75034       {
75035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75036       };
75037     } catch (...) {
75038       {
75039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75040       };
75041     }
75042   }
75043
75044 }
75045
75046
75047 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetOrientation(void * jarg1) {
75048   int jresult ;
75049   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75050   Dali::Toolkit::ControlOrientation::Type result;
75051
75052   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75053   {
75054     try {
75055       result = (Dali::Toolkit::ControlOrientation::Type)((Dali::Toolkit::ItemLayout const *)arg1)->GetOrientation();
75056     } catch (std::out_of_range& e) {
75057       {
75058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75059       };
75060     } catch (std::exception& e) {
75061       {
75062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75063       };
75064     } catch (Dali::DaliException e) {
75065       {
75066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75067       };
75068     } catch (...) {
75069       {
75070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75071       };
75072     }
75073   }
75074
75075   jresult = (int)result;
75076   return jresult;
75077 }
75078
75079
75080 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetLayoutProperties(void * jarg1, void * jarg2) {
75081   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75082   Dali::Property::Map *arg2 = 0 ;
75083
75084   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75085   arg2 = (Dali::Property::Map *)jarg2;
75086   if (!arg2) {
75087     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
75088     return ;
75089   }
75090   {
75091     try {
75092       (arg1)->SetLayoutProperties((Dali::Property::Map const &)*arg2);
75093     } catch (std::out_of_range& e) {
75094       {
75095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75096       };
75097     } catch (std::exception& e) {
75098       {
75099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75100       };
75101     } catch (Dali::DaliException e) {
75102       {
75103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75104       };
75105     } catch (...) {
75106       {
75107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75108       };
75109     }
75110   }
75111
75112 }
75113
75114
75115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetLayoutProperties(void * jarg1) {
75116   void * jresult ;
75117   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75118   Dali::Property::Map result;
75119
75120   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75121   {
75122     try {
75123       result = (arg1)->GetLayoutProperties();
75124     } catch (std::out_of_range& e) {
75125       {
75126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75127       };
75128     } catch (std::exception& e) {
75129       {
75130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75131       };
75132     } catch (Dali::DaliException e) {
75133       {
75134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75135       };
75136     } catch (...) {
75137       {
75138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75139       };
75140     }
75141   }
75142
75143   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
75144   return jresult;
75145 }
75146
75147
75148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
75149   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75150   unsigned int arg2 ;
75151   Dali::Vector3 *arg3 = 0 ;
75152   Dali::Vector3 *arg4 = 0 ;
75153
75154   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75155   arg2 = (unsigned int)jarg2;
75156   arg3 = (Dali::Vector3 *)jarg3;
75157   if (!arg3) {
75158     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75159     return ;
75160   }
75161   arg4 = (Dali::Vector3 *)jarg4;
75162   if (!arg4) {
75163     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
75164     return ;
75165   }
75166   {
75167     try {
75168       ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
75169     } catch (std::out_of_range& e) {
75170       {
75171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75172       };
75173     } catch (std::exception& e) {
75174       {
75175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75176       };
75177     } catch (Dali::DaliException e) {
75178       {
75179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75180       };
75181     } catch (...) {
75182       {
75183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75184       };
75185     }
75186   }
75187
75188 }
75189
75190
75191 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetItemSize(void * jarg1, void * jarg2) {
75192   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75193   Dali::Vector3 *arg2 = 0 ;
75194
75195   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75196   arg2 = (Dali::Vector3 *)jarg2;
75197   if (!arg2) {
75198     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75199     return ;
75200   }
75201   {
75202     try {
75203       (arg1)->SetItemSize((Dali::Vector3 const &)*arg2);
75204     } catch (std::out_of_range& e) {
75205       {
75206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75207       };
75208     } catch (std::exception& e) {
75209       {
75210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75211       };
75212     } catch (Dali::DaliException e) {
75213       {
75214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75215       };
75216     } catch (...) {
75217       {
75218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75219       };
75220     }
75221   }
75222
75223 }
75224
75225
75226 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMinimumLayoutPosition(void * jarg1, unsigned int jarg2, void * jarg3) {
75227   float jresult ;
75228   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75229   unsigned int arg2 ;
75230   Dali::Vector3 arg3 ;
75231   Dali::Vector3 *argp3 ;
75232   float result;
75233
75234   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75235   arg2 = (unsigned int)jarg2;
75236   argp3 = (Dali::Vector3 *)jarg3;
75237   if (!argp3) {
75238     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
75239     return 0;
75240   }
75241   arg3 = *argp3;
75242   {
75243     try {
75244       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMinimumLayoutPosition(arg2,arg3);
75245     } catch (std::out_of_range& e) {
75246       {
75247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75248       };
75249     } catch (std::exception& e) {
75250       {
75251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75252       };
75253     } catch (Dali::DaliException e) {
75254       {
75255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75256       };
75257     } catch (...) {
75258       {
75259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75260       };
75261     }
75262   }
75263
75264   jresult = result;
75265   return jresult;
75266 }
75267
75268
75269 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestAnchorPosition(void * jarg1, float jarg2) {
75270   float jresult ;
75271   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75272   float arg2 ;
75273   float result;
75274
75275   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75276   arg2 = (float)jarg2;
75277   {
75278     try {
75279       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetClosestAnchorPosition(arg2);
75280     } catch (std::out_of_range& e) {
75281       {
75282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75283       };
75284     } catch (std::exception& e) {
75285       {
75286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75287       };
75288     } catch (Dali::DaliException e) {
75289       {
75290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75291       };
75292     } catch (...) {
75293       {
75294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75295       };
75296     }
75297   }
75298
75299   jresult = result;
75300   return jresult;
75301 }
75302
75303
75304 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemScrollToPosition(void * jarg1, unsigned int jarg2) {
75305   float jresult ;
75306   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75307   unsigned int arg2 ;
75308   float result;
75309
75310   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75311   arg2 = (unsigned int)jarg2;
75312   {
75313     try {
75314       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemScrollToPosition(arg2);
75315     } catch (std::out_of_range& e) {
75316       {
75317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75318       };
75319     } catch (std::exception& e) {
75320       {
75321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75322       };
75323     } catch (Dali::DaliException e) {
75324       {
75325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75326       };
75327     } catch (...) {
75328       {
75329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75330       };
75331     }
75332   }
75333
75334   jresult = result;
75335   return jresult;
75336 }
75337
75338
75339 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemsWithinArea(void * jarg1, float jarg2, void * jarg3) {
75340   void * jresult ;
75341   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75342   float arg2 ;
75343   Dali::Vector3 arg3 ;
75344   Dali::Vector3 *argp3 ;
75345   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
75346
75347   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75348   arg2 = (float)jarg2;
75349   argp3 = (Dali::Vector3 *)jarg3;
75350   if (!argp3) {
75351     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
75352     return 0;
75353   }
75354   arg3 = *argp3;
75355   {
75356     try {
75357       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemsWithinArea(arg2,arg3);
75358     } catch (std::out_of_range& e) {
75359       {
75360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75361       };
75362     } catch (std::exception& e) {
75363       {
75364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75365       };
75366     } catch (Dali::DaliException e) {
75367       {
75368         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75369       };
75370     } catch (...) {
75371       {
75372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75373       };
75374     }
75375   }
75376
75377   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
75378   return jresult;
75379 }
75380
75381
75382 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestOnScreenLayoutPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
75383   float jresult ;
75384   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75385   int arg2 ;
75386   float arg3 ;
75387   Dali::Vector3 *arg4 = 0 ;
75388   float result;
75389
75390   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75391   arg2 = (int)jarg2;
75392   arg3 = (float)jarg3;
75393   arg4 = (Dali::Vector3 *)jarg4;
75394   if (!arg4) {
75395     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75396     return 0;
75397   }
75398   {
75399     try {
75400       result = (float)(arg1)->GetClosestOnScreenLayoutPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
75401     } catch (std::out_of_range& e) {
75402       {
75403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75404       };
75405     } catch (std::exception& e) {
75406       {
75407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75408       };
75409     } catch (Dali::DaliException e) {
75410       {
75411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75412       };
75413     } catch (...) {
75414       {
75415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75416       };
75417     }
75418   }
75419
75420   jresult = result;
75421   return jresult;
75422 }
75423
75424
75425 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemLayout_GetReserveItemCount(void * jarg1, void * jarg2) {
75426   unsigned int jresult ;
75427   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75428   Dali::Vector3 arg2 ;
75429   Dali::Vector3 *argp2 ;
75430   unsigned int result;
75431
75432   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75433   argp2 = (Dali::Vector3 *)jarg2;
75434   if (!argp2) {
75435     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
75436     return 0;
75437   }
75438   arg2 = *argp2;
75439   {
75440     try {
75441       result = (unsigned int)((Dali::Toolkit::ItemLayout const *)arg1)->GetReserveItemCount(arg2);
75442     } catch (std::out_of_range& e) {
75443       {
75444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75445       };
75446     } catch (std::exception& e) {
75447       {
75448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75449       };
75450     } catch (Dali::DaliException e) {
75451       {
75452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75453       };
75454     } catch (...) {
75455       {
75456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75457       };
75458     }
75459   }
75460
75461   jresult = result;
75462   return jresult;
75463 }
75464
75465
75466 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetDefaultItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
75467   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75468   unsigned int arg2 ;
75469   Dali::Vector3 *arg3 = 0 ;
75470   Dali::Vector3 *arg4 = 0 ;
75471
75472   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75473   arg2 = (unsigned int)jarg2;
75474   arg3 = (Dali::Vector3 *)jarg3;
75475   if (!arg3) {
75476     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75477     return ;
75478   }
75479   arg4 = (Dali::Vector3 *)jarg4;
75480   if (!arg4) {
75481     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
75482     return ;
75483   }
75484   {
75485     try {
75486       ((Dali::Toolkit::ItemLayout const *)arg1)->GetDefaultItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
75487     } catch (std::out_of_range& e) {
75488       {
75489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75490       };
75491     } catch (std::exception& e) {
75492       {
75493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75494       };
75495     } catch (Dali::DaliException e) {
75496       {
75497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75498       };
75499     } catch (...) {
75500       {
75501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75502       };
75503     }
75504   }
75505
75506 }
75507
75508
75509 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollDirection(void * jarg1) {
75510   void * jresult ;
75511   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75512   Dali::Degree result;
75513
75514   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75515   {
75516     try {
75517       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollDirection();
75518     } catch (std::out_of_range& e) {
75519       {
75520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75521       };
75522     } catch (std::exception& e) {
75523       {
75524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75525       };
75526     } catch (Dali::DaliException e) {
75527       {
75528         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75529       };
75530     } catch (...) {
75531       {
75532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75533       };
75534     }
75535   }
75536
75537   jresult = new Dali::Degree((const Dali::Degree &)result);
75538   return jresult;
75539 }
75540
75541
75542 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollSpeedFactor(void * jarg1) {
75543   float jresult ;
75544   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75545   float result;
75546
75547   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75548   {
75549     try {
75550       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollSpeedFactor();
75551     } catch (std::out_of_range& e) {
75552       {
75553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75554       };
75555     } catch (std::exception& e) {
75556       {
75557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75558       };
75559     } catch (Dali::DaliException e) {
75560       {
75561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75562       };
75563     } catch (...) {
75564       {
75565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75566       };
75567     }
75568   }
75569
75570   jresult = result;
75571   return jresult;
75572 }
75573
75574
75575 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMaximumSwipeSpeed(void * jarg1) {
75576   float jresult ;
75577   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75578   float result;
75579
75580   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75581   {
75582     try {
75583       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMaximumSwipeSpeed();
75584     } catch (std::out_of_range& e) {
75585       {
75586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75587       };
75588     } catch (std::exception& e) {
75589       {
75590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75591       };
75592     } catch (Dali::DaliException e) {
75593       {
75594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75595       };
75596     } catch (...) {
75597       {
75598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75599       };
75600     }
75601   }
75602
75603   jresult = result;
75604   return jresult;
75605 }
75606
75607
75608 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemFlickAnimationDuration(void * jarg1) {
75609   float jresult ;
75610   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75611   float result;
75612
75613   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75614   {
75615     try {
75616       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemFlickAnimationDuration();
75617     } catch (std::out_of_range& e) {
75618       {
75619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75620       };
75621     } catch (std::exception& e) {
75622       {
75623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75624       };
75625     } catch (Dali::DaliException e) {
75626       {
75627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75628       };
75629     } catch (...) {
75630       {
75631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75632       };
75633     }
75634   }
75635
75636   jresult = result;
75637   return jresult;
75638 }
75639
75640
75641 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetNextFocusItemID(void * jarg1, int jarg2, int jarg3, int jarg4, unsigned int jarg5) {
75642   int jresult ;
75643   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75644   int arg2 ;
75645   int arg3 ;
75646   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
75647   bool arg5 ;
75648   int result;
75649
75650   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75651   arg2 = (int)jarg2;
75652   arg3 = (int)jarg3;
75653   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
75654   arg5 = jarg5 ? true : false;
75655   {
75656     try {
75657       result = (int)(arg1)->GetNextFocusItemID(arg2,arg3,arg4,arg5);
75658     } catch (std::out_of_range& e) {
75659       {
75660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75661       };
75662     } catch (std::exception& e) {
75663       {
75664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75665       };
75666     } catch (Dali::DaliException e) {
75667       {
75668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75669       };
75670     } catch (...) {
75671       {
75672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75673       };
75674     }
75675   }
75676
75677   jresult = result;
75678   return jresult;
75679 }
75680
75681
75682 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetFlickSpeedFactor(void * jarg1) {
75683   float jresult ;
75684   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75685   float result;
75686
75687   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75688   {
75689     try {
75690       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetFlickSpeedFactor();
75691     } catch (std::out_of_range& e) {
75692       {
75693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75694       };
75695     } catch (std::exception& e) {
75696       {
75697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75698       };
75699     } catch (Dali::DaliException e) {
75700       {
75701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75702       };
75703     } catch (...) {
75704       {
75705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75706       };
75707     }
75708   }
75709
75710   jresult = result;
75711   return jresult;
75712 }
75713
75714
75715 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_ApplyConstraints(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5) {
75716   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75717   Dali::Actor *arg2 = 0 ;
75718   int arg3 ;
75719   Dali::Vector3 *arg4 = 0 ;
75720   Dali::Actor *arg5 = 0 ;
75721
75722   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75723   arg2 = (Dali::Actor *)jarg2;
75724   if (!arg2) {
75725     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
75726     return ;
75727   }
75728   arg3 = (int)jarg3;
75729   arg4 = (Dali::Vector3 *)jarg4;
75730   if (!arg4) {
75731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75732     return ;
75733   }
75734   arg5 = (Dali::Actor *)jarg5;
75735   if (!arg5) {
75736     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
75737     return ;
75738   }
75739   {
75740     try {
75741       (arg1)->ApplyConstraints(*arg2,arg3,(Dali::Vector3 const &)*arg4,(Dali::Actor const &)*arg5);
75742     } catch (std::out_of_range& e) {
75743       {
75744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75745       };
75746     } catch (std::exception& e) {
75747       {
75748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75749       };
75750     } catch (Dali::DaliException e) {
75751       {
75752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75753       };
75754     } catch (...) {
75755       {
75756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75757       };
75758     }
75759   }
75760
75761 }
75762
75763
75764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
75765   void * jresult ;
75766   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75767   int arg2 ;
75768   float arg3 ;
75769   Dali::Vector3 *arg4 = 0 ;
75770   Dali::Vector3 result;
75771
75772   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75773   arg2 = (int)jarg2;
75774   arg3 = (float)jarg3;
75775   arg4 = (Dali::Vector3 *)jarg4;
75776   if (!arg4) {
75777     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75778     return 0;
75779   }
75780   {
75781     try {
75782       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
75783     } catch (std::out_of_range& e) {
75784       {
75785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75786       };
75787     } catch (std::exception& e) {
75788       {
75789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75790       };
75791     } catch (Dali::DaliException e) {
75792       {
75793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75794       };
75795     } catch (...) {
75796       {
75797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75798       };
75799     }
75800   }
75801
75802   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
75803   return jresult;
75804 }
75805
75806
75807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NewItemLayout(int jarg1) {
75808   void * jresult ;
75809   Dali::Toolkit::DefaultItemLayout::Type arg1 ;
75810   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
75811
75812   arg1 = (Dali::Toolkit::DefaultItemLayout::Type)jarg1;
75813   {
75814     try {
75815       result = Dali::Toolkit::DefaultItemLayout::New(arg1);
75816     } catch (std::out_of_range& e) {
75817       {
75818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75819       };
75820     } catch (std::exception& e) {
75821       {
75822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75823       };
75824     } catch (Dali::DaliException e) {
75825       {
75826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75827       };
75828     } catch (...) {
75829       {
75830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75831       };
75832     }
75833   }
75834
75835   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
75836   return jresult;
75837 }
75838
75839
75840 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemFactory(void * jarg1) {
75841   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
75842
75843   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75844   {
75845     try {
75846       delete arg1;
75847     } catch (std::out_of_range& e) {
75848       {
75849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75850       };
75851     } catch (std::exception& e) {
75852       {
75853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75854       };
75855     } catch (Dali::DaliException e) {
75856       {
75857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75858       };
75859     } catch (...) {
75860       {
75861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75862       };
75863     }
75864   }
75865
75866 }
75867
75868
75869 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemFactory_GetNumberOfItems(void * jarg1) {
75870   unsigned int jresult ;
75871   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
75872   unsigned int result;
75873
75874   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75875   {
75876     try {
75877       result = (unsigned int)(arg1)->GetNumberOfItems();
75878     } catch (std::out_of_range& e) {
75879       {
75880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75881       };
75882     } catch (std::exception& e) {
75883       {
75884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75885       };
75886     } catch (Dali::DaliException e) {
75887       {
75888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75889       };
75890     } catch (...) {
75891       {
75892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75893       };
75894     }
75895   }
75896
75897   jresult = result;
75898   return jresult;
75899 }
75900
75901
75902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemFactory_NewItem(void * jarg1, unsigned int jarg2) {
75903   void * jresult ;
75904   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
75905   unsigned int arg2 ;
75906   Dali::Actor result;
75907
75908   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75909   arg2 = (unsigned int)jarg2;
75910   {
75911     try {
75912       result = (arg1)->NewItem(arg2);
75913     } catch (std::out_of_range& e) {
75914       {
75915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75916       };
75917     } catch (std::exception& e) {
75918       {
75919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75920       };
75921     } catch (Dali::DaliException e) {
75922       {
75923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75924       };
75925     } catch (...) {
75926       {
75927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75928       };
75929     }
75930   }
75931
75932   jresult = new Dali::Actor((const Dali::Actor &)result);
75933   return jresult;
75934 }
75935
75936
75937 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleased(void * jarg1, unsigned int jarg2, void * jarg3) {
75938   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
75939   unsigned int arg2 ;
75940   Dali::Actor arg3 ;
75941   Dali::Actor *argp3 ;
75942
75943   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75944   arg2 = (unsigned int)jarg2;
75945   argp3 = (Dali::Actor *)jarg3;
75946   if (!argp3) {
75947     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75948     return ;
75949   }
75950   arg3 = *argp3;
75951   {
75952     try {
75953       (arg1)->ItemReleased(arg2,arg3);
75954     } catch (std::out_of_range& e) {
75955       {
75956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75957       };
75958     } catch (std::exception& e) {
75959       {
75960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75961       };
75962     } catch (Dali::DaliException e) {
75963       {
75964         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75965       };
75966     } catch (...) {
75967       {
75968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75969       };
75970     }
75971   }
75972
75973 }
75974
75975
75976 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleasedSwigExplicitItemFactory(void * jarg1, unsigned int jarg2, void * jarg3) {
75977   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
75978   unsigned int arg2 ;
75979   Dali::Actor arg3 ;
75980   Dali::Actor *argp3 ;
75981
75982   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75983   arg2 = (unsigned int)jarg2;
75984   argp3 = (Dali::Actor *)jarg3;
75985   if (!argp3) {
75986     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75987     return ;
75988   }
75989   arg3 = *argp3;
75990   {
75991     try {
75992       (arg1)->Dali::Toolkit::ItemFactory::ItemReleased(arg2,arg3);
75993     } catch (std::out_of_range& e) {
75994       {
75995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75996       };
75997     } catch (std::exception& e) {
75998       {
75999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76000       };
76001     } catch (Dali::DaliException e) {
76002       {
76003         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76004       };
76005     } catch (...) {
76006       {
76007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76008       };
76009     }
76010   }
76011
76012 }
76013
76014
76015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemFactory() {
76016   void * jresult ;
76017   Dali::Toolkit::ItemFactory *result = 0 ;
76018
76019   {
76020     try {
76021       result = (Dali::Toolkit::ItemFactory *)new SwigDirector_ItemFactory();
76022     } catch (std::out_of_range& e) {
76023       {
76024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76025       };
76026     } catch (std::exception& e) {
76027       {
76028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76029       };
76030     } catch (Dali::DaliException e) {
76031       {
76032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76033       };
76034     } catch (...) {
76035       {
76036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76037       };
76038     }
76039   }
76040
76041   jresult = (void *)result;
76042   return jresult;
76043 }
76044
76045
76046 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) {
76047   Dali::Toolkit::ItemFactory *obj = (Dali::Toolkit::ItemFactory *)objarg;
76048   SwigDirector_ItemFactory *director = dynamic_cast<SwigDirector_ItemFactory *>(obj);
76049   if (director) {
76050     director->swig_connect_director(callback0, callback1, callback2);
76051   }
76052 }
76053
76054
76055 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_SPEED_get() {
76056   int jresult ;
76057   int result;
76058
76059   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_SPEED;
76060   jresult = (int)result;
76061   return jresult;
76062 }
76063
76064
76065 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_DISTANCE_get() {
76066   int jresult ;
76067   int result;
76068
76069   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_DISTANCE;
76070   jresult = (int)result;
76071   return jresult;
76072 }
76073
76074
76075 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
76076   int jresult ;
76077   int result;
76078
76079   result = (int)Dali::Toolkit::ItemView::Property::WHEEL_SCROLL_DISTANCE_STEP;
76080   jresult = (int)result;
76081   return jresult;
76082 }
76083
76084
76085 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SNAP_TO_ITEM_ENABLED_get() {
76086   int jresult ;
76087   int result;
76088
76089   result = (int)Dali::Toolkit::ItemView::Property::SNAP_TO_ITEM_ENABLED;
76090   jresult = (int)result;
76091   return jresult;
76092 }
76093
76094
76095 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_REFRESH_INTERVAL_get() {
76096   int jresult ;
76097   int result;
76098
76099   result = (int)Dali::Toolkit::ItemView::Property::REFRESH_INTERVAL;
76100   jresult = (int)result;
76101   return jresult;
76102 }
76103
76104
76105 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_POSITION_get() {
76106   int jresult ;
76107   int result;
76108
76109   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_POSITION;
76110   jresult = (int)result;
76111   return jresult;
76112 }
76113
76114
76115 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_SPEED_get() {
76116   int jresult ;
76117   int result;
76118
76119   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_SPEED;
76120   jresult = (int)result;
76121   return jresult;
76122 }
76123
76124
76125 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_OVERSHOOT_get() {
76126   int jresult ;
76127   int result;
76128
76129   result = (int)Dali::Toolkit::ItemView::Property::OVERSHOOT;
76130   jresult = (int)result;
76131   return jresult;
76132 }
76133
76134
76135 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_DIRECTION_get() {
76136   int jresult ;
76137   int result;
76138
76139   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_DIRECTION;
76140   jresult = (int)result;
76141   return jresult;
76142 }
76143
76144
76145 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_ORIENTATION_get() {
76146   int jresult ;
76147   int result;
76148
76149   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_ORIENTATION;
76150   jresult = (int)result;
76151   return jresult;
76152 }
76153
76154
76155 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_CONTENT_SIZE_get() {
76156   int jresult ;
76157   int result;
76158
76159   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_CONTENT_SIZE;
76160   jresult = (int)result;
76161   return jresult;
76162 }
76163
76164
76165 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView_Property() {
76166   void * jresult ;
76167   Dali::Toolkit::ItemView::Property *result = 0 ;
76168
76169   {
76170     try {
76171       result = (Dali::Toolkit::ItemView::Property *)new Dali::Toolkit::ItemView::Property();
76172     } catch (std::out_of_range& e) {
76173       {
76174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76175       };
76176     } catch (std::exception& e) {
76177       {
76178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76179       };
76180     } catch (Dali::DaliException e) {
76181       {
76182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76183       };
76184     } catch (...) {
76185       {
76186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76187       };
76188     }
76189   }
76190
76191   jresult = (void *)result;
76192   return jresult;
76193 }
76194
76195
76196 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView_Property(void * jarg1) {
76197   Dali::Toolkit::ItemView::Property *arg1 = (Dali::Toolkit::ItemView::Property *) 0 ;
76198
76199   arg1 = (Dali::Toolkit::ItemView::Property *)jarg1;
76200   {
76201     try {
76202       delete arg1;
76203     } catch (std::out_of_range& e) {
76204       {
76205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76206       };
76207     } catch (std::exception& e) {
76208       {
76209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76210       };
76211     } catch (Dali::DaliException e) {
76212       {
76213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76214       };
76215     } catch (...) {
76216       {
76217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76218       };
76219     }
76220   }
76221
76222 }
76223
76224
76225 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_0() {
76226   void * jresult ;
76227   Dali::Toolkit::ItemView *result = 0 ;
76228
76229   {
76230     try {
76231       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView();
76232     } catch (std::out_of_range& e) {
76233       {
76234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76235       };
76236     } catch (std::exception& e) {
76237       {
76238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76239       };
76240     } catch (Dali::DaliException e) {
76241       {
76242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76243       };
76244     } catch (...) {
76245       {
76246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76247       };
76248     }
76249   }
76250
76251   jresult = (void *)result;
76252   return jresult;
76253 }
76254
76255
76256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_1(void * jarg1) {
76257   void * jresult ;
76258   Dali::Toolkit::ItemView *arg1 = 0 ;
76259   Dali::Toolkit::ItemView *result = 0 ;
76260
76261   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76262   if (!arg1) {
76263     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
76264     return 0;
76265   }
76266   {
76267     try {
76268       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView((Dali::Toolkit::ItemView const &)*arg1);
76269     } catch (std::out_of_range& e) {
76270       {
76271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76272       };
76273     } catch (std::exception& e) {
76274       {
76275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76276       };
76277     } catch (Dali::DaliException e) {
76278       {
76279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76280       };
76281     } catch (...) {
76282       {
76283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76284       };
76285     }
76286   }
76287
76288   jresult = (void *)result;
76289   return jresult;
76290 }
76291
76292
76293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_Assign(void * jarg1, void * jarg2) {
76294   void * jresult ;
76295   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76296   Dali::Toolkit::ItemView *arg2 = 0 ;
76297   Dali::Toolkit::ItemView *result = 0 ;
76298
76299   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76300   arg2 = (Dali::Toolkit::ItemView *)jarg2;
76301   if (!arg2) {
76302     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
76303     return 0;
76304   }
76305   {
76306     try {
76307       result = (Dali::Toolkit::ItemView *) &(arg1)->operator =((Dali::Toolkit::ItemView const &)*arg2);
76308     } catch (std::out_of_range& e) {
76309       {
76310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76311       };
76312     } catch (std::exception& e) {
76313       {
76314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76315       };
76316     } catch (Dali::DaliException e) {
76317       {
76318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76319       };
76320     } catch (...) {
76321       {
76322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76323       };
76324     }
76325   }
76326
76327   jresult = (void *)result;
76328   return jresult;
76329 }
76330
76331
76332 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView(void * jarg1) {
76333   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76334
76335   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76336   {
76337     try {
76338       delete arg1;
76339     } catch (std::out_of_range& e) {
76340       {
76341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76342       };
76343     } catch (std::exception& e) {
76344       {
76345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76346       };
76347     } catch (Dali::DaliException e) {
76348       {
76349         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76350       };
76351     } catch (...) {
76352       {
76353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76354       };
76355     }
76356   }
76357
76358 }
76359
76360
76361 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_New(void * jarg1) {
76362   void * jresult ;
76363   Dali::Toolkit::ItemFactory *arg1 = 0 ;
76364   Dali::Toolkit::ItemView result;
76365
76366   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
76367   if (!arg1) {
76368     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemFactory & type is null", 0);
76369     return 0;
76370   }
76371   {
76372     try {
76373       result = Dali::Toolkit::ItemView::New(*arg1);
76374     } catch (std::out_of_range& e) {
76375       {
76376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76377       };
76378     } catch (std::exception& e) {
76379       {
76380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76381       };
76382     } catch (Dali::DaliException e) {
76383       {
76384         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76385       };
76386     } catch (...) {
76387       {
76388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76389       };
76390     }
76391   }
76392
76393   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
76394   return jresult;
76395 }
76396
76397
76398 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_DownCast(void * jarg1) {
76399   void * jresult ;
76400   Dali::BaseHandle arg1 ;
76401   Dali::BaseHandle *argp1 ;
76402   Dali::Toolkit::ItemView result;
76403
76404   argp1 = (Dali::BaseHandle *)jarg1;
76405   if (!argp1) {
76406     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
76407     return 0;
76408   }
76409   arg1 = *argp1;
76410   {
76411     try {
76412       result = Dali::Toolkit::ItemView::DownCast(arg1);
76413     } catch (std::out_of_range& e) {
76414       {
76415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76416       };
76417     } catch (std::exception& e) {
76418       {
76419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76420       };
76421     } catch (Dali::DaliException e) {
76422       {
76423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76424       };
76425     } catch (...) {
76426       {
76427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76428       };
76429     }
76430   }
76431
76432   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
76433   return jresult;
76434 }
76435
76436
76437 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetLayoutCount(void * jarg1) {
76438   unsigned int jresult ;
76439   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76440   unsigned int result;
76441
76442   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76443   {
76444     try {
76445       result = (unsigned int)((Dali::Toolkit::ItemView const *)arg1)->GetLayoutCount();
76446     } catch (std::out_of_range& e) {
76447       {
76448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76449       };
76450     } catch (std::exception& e) {
76451       {
76452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76453       };
76454     } catch (Dali::DaliException e) {
76455       {
76456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76457       };
76458     } catch (...) {
76459       {
76460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76461       };
76462     }
76463   }
76464
76465   jresult = result;
76466   return jresult;
76467 }
76468
76469
76470 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_AddLayout(void * jarg1, void * jarg2) {
76471   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76472   Dali::Toolkit::ItemLayout *arg2 = 0 ;
76473
76474   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76475   arg2 = (Dali::Toolkit::ItemLayout *)jarg2;
76476   if (!arg2) {
76477     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemLayout & type is null", 0);
76478     return ;
76479   }
76480   {
76481     try {
76482       (arg1)->AddLayout(*arg2);
76483     } catch (std::out_of_range& e) {
76484       {
76485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76486       };
76487     } catch (std::exception& e) {
76488       {
76489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76490       };
76491     } catch (Dali::DaliException e) {
76492       {
76493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76494       };
76495     } catch (...) {
76496       {
76497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76498       };
76499     }
76500   }
76501
76502 }
76503
76504
76505 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveLayout(void * jarg1, unsigned int jarg2) {
76506   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76507   unsigned int arg2 ;
76508
76509   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76510   arg2 = (unsigned int)jarg2;
76511   {
76512     try {
76513       (arg1)->RemoveLayout(arg2);
76514     } catch (std::out_of_range& e) {
76515       {
76516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76517       };
76518     } catch (std::exception& e) {
76519       {
76520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76521       };
76522     } catch (Dali::DaliException e) {
76523       {
76524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76525       };
76526     } catch (...) {
76527       {
76528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76529       };
76530     }
76531   }
76532
76533 }
76534
76535
76536 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetLayout(void * jarg1, unsigned int jarg2) {
76537   void * jresult ;
76538   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76539   unsigned int arg2 ;
76540   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
76541
76542   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76543   arg2 = (unsigned int)jarg2;
76544   {
76545     try {
76546       result = ((Dali::Toolkit::ItemView const *)arg1)->GetLayout(arg2);
76547     } catch (std::out_of_range& e) {
76548       {
76549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76550       };
76551     } catch (std::exception& e) {
76552       {
76553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76554       };
76555     } catch (Dali::DaliException e) {
76556       {
76557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76558       };
76559     } catch (...) {
76560       {
76561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76562       };
76563     }
76564   }
76565
76566   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
76567   return jresult;
76568 }
76569
76570
76571 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetActiveLayout(void * jarg1) {
76572   void * jresult ;
76573   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76574   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
76575
76576   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76577   {
76578     try {
76579       result = ((Dali::Toolkit::ItemView const *)arg1)->GetActiveLayout();
76580     } catch (std::out_of_range& e) {
76581       {
76582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76583       };
76584     } catch (std::exception& e) {
76585       {
76586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76587       };
76588     } catch (Dali::DaliException e) {
76589       {
76590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76591       };
76592     } catch (...) {
76593       {
76594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76595       };
76596     }
76597   }
76598
76599   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
76600   return jresult;
76601 }
76602
76603
76604 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetCurrentLayoutPosition(void * jarg1, unsigned int jarg2) {
76605   float jresult ;
76606   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76607   Dali::Toolkit::ItemId arg2 ;
76608   float result;
76609
76610   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76611   arg2 = (Dali::Toolkit::ItemId)jarg2;
76612   {
76613     try {
76614       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetCurrentLayoutPosition(arg2);
76615     } catch (std::out_of_range& e) {
76616       {
76617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76618       };
76619     } catch (std::exception& e) {
76620       {
76621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76622       };
76623     } catch (Dali::DaliException e) {
76624       {
76625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76626       };
76627     } catch (...) {
76628       {
76629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76630       };
76631     }
76632   }
76633
76634   jresult = result;
76635   return jresult;
76636 }
76637
76638
76639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ActivateLayout(void * jarg1, unsigned int jarg2, void * jarg3, float jarg4) {
76640   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76641   unsigned int arg2 ;
76642   Dali::Vector3 arg3 ;
76643   float arg4 ;
76644   Dali::Vector3 *argp3 ;
76645
76646   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76647   arg2 = (unsigned int)jarg2;
76648   argp3 = (Dali::Vector3 *)jarg3;
76649   if (!argp3) {
76650     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
76651     return ;
76652   }
76653   arg3 = *argp3;
76654   arg4 = (float)jarg4;
76655   {
76656     try {
76657       (arg1)->ActivateLayout(arg2,arg3,arg4);
76658     } catch (std::out_of_range& e) {
76659       {
76660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76661       };
76662     } catch (std::exception& e) {
76663       {
76664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76665       };
76666     } catch (Dali::DaliException e) {
76667       {
76668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76669       };
76670     } catch (...) {
76671       {
76672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76673       };
76674     }
76675   }
76676
76677 }
76678
76679
76680 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_DeactivateCurrentLayout(void * jarg1) {
76681   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76682
76683   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76684   {
76685     try {
76686       (arg1)->DeactivateCurrentLayout();
76687     } catch (std::out_of_range& e) {
76688       {
76689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76690       };
76691     } catch (std::exception& e) {
76692       {
76693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76694       };
76695     } catch (Dali::DaliException e) {
76696       {
76697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76698       };
76699     } catch (...) {
76700       {
76701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76702       };
76703     }
76704   }
76705
76706 }
76707
76708
76709 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeSpeed(void * jarg1, float jarg2) {
76710   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76711   float arg2 ;
76712
76713   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76714   arg2 = (float)jarg2;
76715   {
76716     try {
76717       (arg1)->SetMinimumSwipeSpeed(arg2);
76718     } catch (std::out_of_range& e) {
76719       {
76720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76721       };
76722     } catch (std::exception& e) {
76723       {
76724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76725       };
76726     } catch (Dali::DaliException e) {
76727       {
76728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76729       };
76730     } catch (...) {
76731       {
76732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76733       };
76734     }
76735   }
76736
76737 }
76738
76739
76740 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeSpeed(void * jarg1) {
76741   float jresult ;
76742   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76743   float result;
76744
76745   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76746   {
76747     try {
76748       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeSpeed();
76749     } catch (std::out_of_range& e) {
76750       {
76751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76752       };
76753     } catch (std::exception& e) {
76754       {
76755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76756       };
76757     } catch (Dali::DaliException e) {
76758       {
76759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76760       };
76761     } catch (...) {
76762       {
76763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76764       };
76765     }
76766   }
76767
76768   jresult = result;
76769   return jresult;
76770 }
76771
76772
76773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeDistance(void * jarg1, float jarg2) {
76774   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76775   float arg2 ;
76776
76777   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76778   arg2 = (float)jarg2;
76779   {
76780     try {
76781       (arg1)->SetMinimumSwipeDistance(arg2);
76782     } catch (std::out_of_range& e) {
76783       {
76784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76785       };
76786     } catch (std::exception& e) {
76787       {
76788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76789       };
76790     } catch (Dali::DaliException e) {
76791       {
76792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76793       };
76794     } catch (...) {
76795       {
76796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76797       };
76798     }
76799   }
76800
76801 }
76802
76803
76804 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeDistance(void * jarg1) {
76805   float jresult ;
76806   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76807   float result;
76808
76809   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76810   {
76811     try {
76812       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeDistance();
76813     } catch (std::out_of_range& e) {
76814       {
76815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76816       };
76817     } catch (std::exception& e) {
76818       {
76819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76820       };
76821     } catch (Dali::DaliException e) {
76822       {
76823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76824       };
76825     } catch (...) {
76826       {
76827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76828       };
76829     }
76830   }
76831
76832   jresult = result;
76833   return jresult;
76834 }
76835
76836
76837 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetWheelScrollDistanceStep(void * jarg1, float jarg2) {
76838   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76839   float arg2 ;
76840
76841   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76842   arg2 = (float)jarg2;
76843   {
76844     try {
76845       (arg1)->SetWheelScrollDistanceStep(arg2);
76846     } catch (std::out_of_range& e) {
76847       {
76848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76849       };
76850     } catch (std::exception& e) {
76851       {
76852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76853       };
76854     } catch (Dali::DaliException e) {
76855       {
76856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76857       };
76858     } catch (...) {
76859       {
76860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76861       };
76862     }
76863   }
76864
76865 }
76866
76867
76868 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetWheelScrollDistanceStep(void * jarg1) {
76869   float jresult ;
76870   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76871   float result;
76872
76873   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76874   {
76875     try {
76876       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetWheelScrollDistanceStep();
76877     } catch (std::out_of_range& e) {
76878       {
76879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76880       };
76881     } catch (std::exception& e) {
76882       {
76883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76884       };
76885     } catch (Dali::DaliException e) {
76886       {
76887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76888       };
76889     } catch (...) {
76890       {
76891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76892       };
76893     }
76894   }
76895
76896   jresult = result;
76897   return jresult;
76898 }
76899
76900
76901 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoring(void * jarg1, unsigned int jarg2) {
76902   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76903   bool arg2 ;
76904
76905   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76906   arg2 = jarg2 ? true : false;
76907   {
76908     try {
76909       (arg1)->SetAnchoring(arg2);
76910     } catch (std::out_of_range& e) {
76911       {
76912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76913       };
76914     } catch (std::exception& e) {
76915       {
76916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76917       };
76918     } catch (Dali::DaliException e) {
76919       {
76920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76921       };
76922     } catch (...) {
76923       {
76924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76925       };
76926     }
76927   }
76928
76929 }
76930
76931 //// ========================= end of part 3 =============================
76932
76933 //// ========================== start part 4 ===============================
76934
76935
76936 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoring(void * jarg1) {
76937   unsigned int jresult ;
76938   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76939   bool result;
76940
76941   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76942   {
76943     try {
76944       result = (bool)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoring();
76945     } catch (std::out_of_range& e) {
76946       {
76947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76948       };
76949     } catch (std::exception& e) {
76950       {
76951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76952       };
76953     } catch (Dali::DaliException e) {
76954       {
76955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76956       };
76957     } catch (...) {
76958       {
76959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76960       };
76961     }
76962   }
76963
76964   jresult = result;
76965   return jresult;
76966 }
76967
76968
76969 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoringDuration(void * jarg1, float jarg2) {
76970   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76971   float arg2 ;
76972
76973   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76974   arg2 = (float)jarg2;
76975   {
76976     try {
76977       (arg1)->SetAnchoringDuration(arg2);
76978     } catch (std::out_of_range& e) {
76979       {
76980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76981       };
76982     } catch (std::exception& e) {
76983       {
76984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76985       };
76986     } catch (Dali::DaliException e) {
76987       {
76988         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76989       };
76990     } catch (...) {
76991       {
76992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76993       };
76994     }
76995   }
76996
76997 }
76998
76999
77000 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoringDuration(void * jarg1) {
77001   float jresult ;
77002   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77003   float result;
77004
77005   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77006   {
77007     try {
77008       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoringDuration();
77009     } catch (std::out_of_range& e) {
77010       {
77011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77012       };
77013     } catch (std::exception& e) {
77014       {
77015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77016       };
77017     } catch (Dali::DaliException e) {
77018       {
77019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77020       };
77021     } catch (...) {
77022       {
77023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77024       };
77025     }
77026   }
77027
77028   jresult = result;
77029   return jresult;
77030 }
77031
77032
77033 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ScrollToItem(void * jarg1, unsigned int jarg2, float jarg3) {
77034   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77035   Dali::Toolkit::ItemId arg2 ;
77036   float arg3 ;
77037
77038   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77039   arg2 = (Dali::Toolkit::ItemId)jarg2;
77040   arg3 = (float)jarg3;
77041   {
77042     try {
77043       (arg1)->ScrollToItem(arg2,arg3);
77044     } catch (std::out_of_range& e) {
77045       {
77046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77047       };
77048     } catch (std::exception& e) {
77049       {
77050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77051       };
77052     } catch (Dali::DaliException e) {
77053       {
77054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77055       };
77056     } catch (...) {
77057       {
77058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77059       };
77060     }
77061   }
77062
77063 }
77064
77065
77066 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetRefreshInterval(void * jarg1, float jarg2) {
77067   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77068   float arg2 ;
77069
77070   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77071   arg2 = (float)jarg2;
77072   {
77073     try {
77074       (arg1)->SetRefreshInterval(arg2);
77075     } catch (std::out_of_range& e) {
77076       {
77077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77078       };
77079     } catch (std::exception& e) {
77080       {
77081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77082       };
77083     } catch (Dali::DaliException e) {
77084       {
77085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77086       };
77087     } catch (...) {
77088       {
77089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77090       };
77091     }
77092   }
77093
77094 }
77095
77096
77097 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetRefreshInterval(void * jarg1) {
77098   float jresult ;
77099   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77100   float result;
77101
77102   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77103   {
77104     try {
77105       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetRefreshInterval();
77106     } catch (std::out_of_range& e) {
77107       {
77108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77109       };
77110     } catch (std::exception& e) {
77111       {
77112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77113       };
77114     } catch (Dali::DaliException e) {
77115       {
77116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77117       };
77118     } catch (...) {
77119       {
77120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77121       };
77122     }
77123   }
77124
77125   jresult = result;
77126   return jresult;
77127 }
77128
77129
77130 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_Refresh(void * jarg1) {
77131   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77132
77133   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77134   {
77135     try {
77136       (arg1)->Refresh();
77137     } catch (std::out_of_range& e) {
77138       {
77139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77140       };
77141     } catch (std::exception& e) {
77142       {
77143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77144       };
77145     } catch (Dali::DaliException e) {
77146       {
77147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77148       };
77149     } catch (...) {
77150       {
77151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77152       };
77153     }
77154   }
77155
77156 }
77157
77158
77159 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItem(void * jarg1, unsigned int jarg2) {
77160   void * jresult ;
77161   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77162   Dali::Toolkit::ItemId arg2 ;
77163   Dali::Actor result;
77164
77165   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77166   arg2 = (Dali::Toolkit::ItemId)jarg2;
77167   {
77168     try {
77169       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItem(arg2);
77170     } catch (std::out_of_range& e) {
77171       {
77172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77173       };
77174     } catch (std::exception& e) {
77175       {
77176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77177       };
77178     } catch (Dali::DaliException e) {
77179       {
77180         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77181       };
77182     } catch (...) {
77183       {
77184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77185       };
77186     }
77187   }
77188
77189   jresult = new Dali::Actor((const Dali::Actor &)result);
77190   return jresult;
77191 }
77192
77193
77194 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetItemId(void * jarg1, void * jarg2) {
77195   unsigned int jresult ;
77196   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77197   Dali::Actor arg2 ;
77198   Dali::Actor *argp2 ;
77199   Dali::Toolkit::ItemId result;
77200
77201   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77202   argp2 = (Dali::Actor *)jarg2;
77203   if (!argp2) {
77204     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
77205     return 0;
77206   }
77207   arg2 = *argp2;
77208   {
77209     try {
77210       result = (Dali::Toolkit::ItemId)((Dali::Toolkit::ItemView const *)arg1)->GetItemId(arg2);
77211     } catch (std::out_of_range& e) {
77212       {
77213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77214       };
77215     } catch (std::exception& e) {
77216       {
77217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77218       };
77219     } catch (Dali::DaliException e) {
77220       {
77221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77222       };
77223     } catch (...) {
77224       {
77225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77226       };
77227     }
77228   }
77229
77230   jresult = result;
77231   return jresult;
77232 }
77233
77234
77235 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItem(void * jarg1, void * jarg2, float jarg3) {
77236   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77237   Dali::Toolkit::Item arg2 ;
77238   float arg3 ;
77239   Dali::Toolkit::Item *argp2 ;
77240
77241   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77242   argp2 = (Dali::Toolkit::Item *)jarg2;
77243   if (!argp2) {
77244     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
77245     return ;
77246   }
77247   arg2 = *argp2;
77248   arg3 = (float)jarg3;
77249   {
77250     try {
77251       (arg1)->InsertItem(arg2,arg3);
77252     } catch (std::out_of_range& e) {
77253       {
77254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77255       };
77256     } catch (std::exception& e) {
77257       {
77258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77259       };
77260     } catch (Dali::DaliException e) {
77261       {
77262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77263       };
77264     } catch (...) {
77265       {
77266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77267       };
77268     }
77269   }
77270
77271 }
77272
77273
77274 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItems(void * jarg1, void * jarg2, float jarg3) {
77275   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77276   Dali::Toolkit::ItemContainer *arg2 = 0 ;
77277   float arg3 ;
77278
77279   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77280   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
77281   if (!arg2) {
77282     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
77283     return ;
77284   }
77285   arg3 = (float)jarg3;
77286   {
77287     try {
77288       (arg1)->InsertItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
77289     } catch (std::out_of_range& e) {
77290       {
77291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77292       };
77293     } catch (std::exception& e) {
77294       {
77295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77296       };
77297     } catch (Dali::DaliException e) {
77298       {
77299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77300       };
77301     } catch (...) {
77302       {
77303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77304       };
77305     }
77306   }
77307
77308 }
77309
77310
77311 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItem(void * jarg1, unsigned int jarg2, float jarg3) {
77312   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77313   Dali::Toolkit::ItemId arg2 ;
77314   float arg3 ;
77315
77316   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77317   arg2 = (Dali::Toolkit::ItemId)jarg2;
77318   arg3 = (float)jarg3;
77319   {
77320     try {
77321       (arg1)->RemoveItem(arg2,arg3);
77322     } catch (std::out_of_range& e) {
77323       {
77324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77325       };
77326     } catch (std::exception& e) {
77327       {
77328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77329       };
77330     } catch (Dali::DaliException e) {
77331       {
77332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77333       };
77334     } catch (...) {
77335       {
77336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77337       };
77338     }
77339   }
77340
77341 }
77342
77343
77344 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItems(void * jarg1, void * jarg2, float jarg3) {
77345   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77346   Dali::Toolkit::ItemIdContainer *arg2 = 0 ;
77347   float arg3 ;
77348
77349   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77350   arg2 = (Dali::Toolkit::ItemIdContainer *)jarg2;
77351   if (!arg2) {
77352     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemIdContainer const & type is null", 0);
77353     return ;
77354   }
77355   arg3 = (float)jarg3;
77356   {
77357     try {
77358       (arg1)->RemoveItems((Dali::Toolkit::ItemIdContainer const &)*arg2,arg3);
77359     } catch (std::out_of_range& e) {
77360       {
77361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77362       };
77363     } catch (std::exception& e) {
77364       {
77365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77366       };
77367     } catch (Dali::DaliException e) {
77368       {
77369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77370       };
77371     } catch (...) {
77372       {
77373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77374       };
77375     }
77376   }
77377
77378 }
77379
77380
77381 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItem(void * jarg1, void * jarg2, float jarg3) {
77382   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77383   Dali::Toolkit::Item arg2 ;
77384   float arg3 ;
77385   Dali::Toolkit::Item *argp2 ;
77386
77387   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77388   argp2 = (Dali::Toolkit::Item *)jarg2;
77389   if (!argp2) {
77390     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
77391     return ;
77392   }
77393   arg2 = *argp2;
77394   arg3 = (float)jarg3;
77395   {
77396     try {
77397       (arg1)->ReplaceItem(arg2,arg3);
77398     } catch (std::out_of_range& e) {
77399       {
77400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77401       };
77402     } catch (std::exception& e) {
77403       {
77404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77405       };
77406     } catch (Dali::DaliException e) {
77407       {
77408         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77409       };
77410     } catch (...) {
77411       {
77412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77413       };
77414     }
77415   }
77416
77417 }
77418
77419
77420 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItems(void * jarg1, void * jarg2, float jarg3) {
77421   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77422   Dali::Toolkit::ItemContainer *arg2 = 0 ;
77423   float arg3 ;
77424
77425   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77426   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
77427   if (!arg2) {
77428     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
77429     return ;
77430   }
77431   arg3 = (float)jarg3;
77432   {
77433     try {
77434       (arg1)->ReplaceItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
77435     } catch (std::out_of_range& e) {
77436       {
77437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77438       };
77439     } catch (std::exception& e) {
77440       {
77441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77442       };
77443     } catch (Dali::DaliException e) {
77444       {
77445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77446       };
77447     } catch (...) {
77448       {
77449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77450       };
77451     }
77452   }
77453
77454 }
77455
77456
77457 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsParentOrigin(void * jarg1, void * jarg2) {
77458   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77459   Dali::Vector3 *arg2 = 0 ;
77460
77461   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77462   arg2 = (Dali::Vector3 *)jarg2;
77463   if (!arg2) {
77464     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
77465     return ;
77466   }
77467   {
77468     try {
77469       (arg1)->SetItemsParentOrigin((Dali::Vector3 const &)*arg2);
77470     } catch (std::out_of_range& e) {
77471       {
77472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77473       };
77474     } catch (std::exception& e) {
77475       {
77476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77477       };
77478     } catch (Dali::DaliException e) {
77479       {
77480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77481       };
77482     } catch (...) {
77483       {
77484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77485       };
77486     }
77487   }
77488
77489 }
77490
77491
77492 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsParentOrigin(void * jarg1) {
77493   void * jresult ;
77494   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77495   Dali::Vector3 result;
77496
77497   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77498   {
77499     try {
77500       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsParentOrigin();
77501     } catch (std::out_of_range& e) {
77502       {
77503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77504       };
77505     } catch (std::exception& e) {
77506       {
77507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77508       };
77509     } catch (Dali::DaliException e) {
77510       {
77511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77512       };
77513     } catch (...) {
77514       {
77515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77516       };
77517     }
77518   }
77519
77520   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
77521   return jresult;
77522 }
77523
77524
77525 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsAnchorPoint(void * jarg1, void * jarg2) {
77526   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77527   Dali::Vector3 *arg2 = 0 ;
77528
77529   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77530   arg2 = (Dali::Vector3 *)jarg2;
77531   if (!arg2) {
77532     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
77533     return ;
77534   }
77535   {
77536     try {
77537       (arg1)->SetItemsAnchorPoint((Dali::Vector3 const &)*arg2);
77538     } catch (std::out_of_range& e) {
77539       {
77540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77541       };
77542     } catch (std::exception& e) {
77543       {
77544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77545       };
77546     } catch (Dali::DaliException e) {
77547       {
77548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77549       };
77550     } catch (...) {
77551       {
77552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77553       };
77554     }
77555   }
77556
77557 }
77558
77559
77560 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsAnchorPoint(void * jarg1) {
77561   void * jresult ;
77562   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77563   Dali::Vector3 result;
77564
77565   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77566   {
77567     try {
77568       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsAnchorPoint();
77569     } catch (std::out_of_range& e) {
77570       {
77571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77572       };
77573     } catch (std::exception& e) {
77574       {
77575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77576       };
77577     } catch (Dali::DaliException e) {
77578       {
77579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77580       };
77581     } catch (...) {
77582       {
77583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77584       };
77585     }
77586   }
77587
77588   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
77589   return jresult;
77590 }
77591
77592
77593 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_GetItemsRange(void * jarg1, void * jarg2) {
77594   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77595   Dali::Toolkit::ItemRange *arg2 = 0 ;
77596
77597   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77598   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
77599   if (!arg2) {
77600     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange & type is null", 0);
77601     return ;
77602   }
77603   {
77604     try {
77605       (arg1)->GetItemsRange(*arg2);
77606     } catch (std::out_of_range& e) {
77607       {
77608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77609       };
77610     } catch (std::exception& e) {
77611       {
77612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77613       };
77614     } catch (Dali::DaliException e) {
77615       {
77616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77617       };
77618     } catch (...) {
77619       {
77620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77621       };
77622     }
77623   }
77624
77625 }
77626
77627
77628 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_LayoutActivatedSignal(void * jarg1) {
77629   void * jresult ;
77630   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77631   Dali::Toolkit::ItemView::LayoutActivatedSignalType *result = 0 ;
77632
77633   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77634   {
77635     try {
77636       result = (Dali::Toolkit::ItemView::LayoutActivatedSignalType *) &(arg1)->LayoutActivatedSignal();
77637     } catch (std::out_of_range& e) {
77638       {
77639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77640       };
77641     } catch (std::exception& e) {
77642       {
77643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77644       };
77645     } catch (Dali::DaliException e) {
77646       {
77647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77648       };
77649     } catch (...) {
77650       {
77651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77652       };
77653     }
77654   }
77655
77656   jresult = (void *)result;
77657   return jresult;
77658 }
77659
77660
77661 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MoveActorConstraint(void * jarg1, void * jarg2) {
77662   Dali::Vector3 *arg1 = 0 ;
77663   PropertyInputContainer *arg2 = 0 ;
77664
77665   arg1 = (Dali::Vector3 *)jarg1;
77666   if (!arg1) {
77667     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
77668     return ;
77669   }
77670   arg2 = (PropertyInputContainer *)jarg2;
77671   if (!arg2) {
77672     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
77673     return ;
77674   }
77675   {
77676     try {
77677       Dali::Toolkit::MoveActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
77678     } catch (std::out_of_range& e) {
77679       {
77680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77681       };
77682     } catch (std::exception& e) {
77683       {
77684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77685       };
77686     } catch (Dali::DaliException e) {
77687       {
77688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77689       };
77690     } catch (...) {
77691       {
77692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77693       };
77694     }
77695   }
77696
77697 }
77698
77699
77700 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WrapActorConstraint(void * jarg1, void * jarg2) {
77701   Dali::Vector3 *arg1 = 0 ;
77702   PropertyInputContainer *arg2 = 0 ;
77703
77704   arg1 = (Dali::Vector3 *)jarg1;
77705   if (!arg1) {
77706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
77707     return ;
77708   }
77709   arg2 = (PropertyInputContainer *)jarg2;
77710   if (!arg2) {
77711     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
77712     return ;
77713   }
77714   {
77715     try {
77716       Dali::Toolkit::WrapActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
77717     } catch (std::out_of_range& e) {
77718       {
77719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77720       };
77721     } catch (std::exception& e) {
77722       {
77723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77724       };
77725     } catch (Dali::DaliException e) {
77726       {
77727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77728       };
77729     } catch (...) {
77730       {
77731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77732       };
77733     }
77734   }
77735
77736 }
77737
77738
77739 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewEffect() {
77740   void * jresult ;
77741   Dali::Toolkit::ScrollViewEffect *result = 0 ;
77742
77743   {
77744     try {
77745       result = (Dali::Toolkit::ScrollViewEffect *)new Dali::Toolkit::ScrollViewEffect();
77746     } catch (std::out_of_range& e) {
77747       {
77748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77749       };
77750     } catch (std::exception& e) {
77751       {
77752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77753       };
77754     } catch (Dali::DaliException e) {
77755       {
77756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77757       };
77758     } catch (...) {
77759       {
77760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77761       };
77762     }
77763   }
77764
77765   jresult = (void *)result;
77766   return jresult;
77767 }
77768
77769
77770 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewEffect(void * jarg1) {
77771   Dali::Toolkit::ScrollViewEffect *arg1 = (Dali::Toolkit::ScrollViewEffect *) 0 ;
77772
77773   arg1 = (Dali::Toolkit::ScrollViewEffect *)jarg1;
77774   {
77775     try {
77776       delete arg1;
77777     } catch (std::out_of_range& e) {
77778       {
77779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77780       };
77781     } catch (std::exception& e) {
77782       {
77783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77784       };
77785     } catch (Dali::DaliException e) {
77786       {
77787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77788       };
77789     } catch (...) {
77790       {
77791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77792       };
77793     }
77794   }
77795
77796 }
77797
77798
77799 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_New(void * jarg1, void * jarg2, int jarg3, void * jarg4, unsigned int jarg5) {
77800   void * jresult ;
77801   Dali::Path arg1 ;
77802   Dali::Vector3 *arg2 = 0 ;
77803   Dali::Property::Index arg3 ;
77804   Dali::Vector3 *arg4 = 0 ;
77805   unsigned int arg5 ;
77806   Dali::Path *argp1 ;
77807   Dali::Toolkit::ScrollViewPagePathEffect result;
77808
77809   argp1 = (Dali::Path *)jarg1;
77810   if (!argp1) {
77811     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
77812     return 0;
77813   }
77814   arg1 = *argp1;
77815   arg2 = (Dali::Vector3 *)jarg2;
77816   if (!arg2) {
77817     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
77818     return 0;
77819   }
77820   arg3 = (Dali::Property::Index)jarg3;
77821   arg4 = (Dali::Vector3 *)jarg4;
77822   if (!arg4) {
77823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
77824     return 0;
77825   }
77826   arg5 = (unsigned int)jarg5;
77827   {
77828     try {
77829       result = Dali::Toolkit::ScrollViewPagePathEffect::New(arg1,(Dali::Vector3 const &)*arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
77830     } catch (std::out_of_range& e) {
77831       {
77832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77833       };
77834     } catch (std::exception& e) {
77835       {
77836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77837       };
77838     } catch (Dali::DaliException e) {
77839       {
77840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77841       };
77842     } catch (...) {
77843       {
77844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77845       };
77846     }
77847   }
77848
77849   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
77850   return jresult;
77851 }
77852
77853
77854 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewPagePathEffect() {
77855   void * jresult ;
77856   Dali::Toolkit::ScrollViewPagePathEffect *result = 0 ;
77857
77858   {
77859     try {
77860       result = (Dali::Toolkit::ScrollViewPagePathEffect *)new Dali::Toolkit::ScrollViewPagePathEffect();
77861     } catch (std::out_of_range& e) {
77862       {
77863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77864       };
77865     } catch (std::exception& e) {
77866       {
77867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77868       };
77869     } catch (Dali::DaliException e) {
77870       {
77871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77872       };
77873     } catch (...) {
77874       {
77875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77876       };
77877     }
77878   }
77879
77880   jresult = (void *)result;
77881   return jresult;
77882 }
77883
77884
77885 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_DownCast(void * jarg1) {
77886   void * jresult ;
77887   Dali::BaseHandle arg1 ;
77888   Dali::BaseHandle *argp1 ;
77889   Dali::Toolkit::ScrollViewPagePathEffect result;
77890
77891   argp1 = (Dali::BaseHandle *)jarg1;
77892   if (!argp1) {
77893     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
77894     return 0;
77895   }
77896   arg1 = *argp1;
77897   {
77898     try {
77899       result = Dali::Toolkit::ScrollViewPagePathEffect::DownCast(arg1);
77900     } catch (std::out_of_range& e) {
77901       {
77902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77903       };
77904     } catch (std::exception& e) {
77905       {
77906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77907       };
77908     } catch (Dali::DaliException e) {
77909       {
77910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77911       };
77912     } catch (...) {
77913       {
77914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77915       };
77916     }
77917   }
77918
77919   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
77920   return jresult;
77921 }
77922
77923
77924 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_ApplyToPage(void * jarg1, void * jarg2, unsigned int jarg3) {
77925   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
77926   Dali::Actor arg2 ;
77927   unsigned int arg3 ;
77928   Dali::Actor *argp2 ;
77929
77930   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
77931   argp2 = (Dali::Actor *)jarg2;
77932   if (!argp2) {
77933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
77934     return ;
77935   }
77936   arg2 = *argp2;
77937   arg3 = (unsigned int)jarg3;
77938   {
77939     try {
77940       (arg1)->ApplyToPage(arg2,arg3);
77941     } catch (std::out_of_range& e) {
77942       {
77943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77944       };
77945     } catch (std::exception& e) {
77946       {
77947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77948       };
77949     } catch (Dali::DaliException e) {
77950       {
77951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77952       };
77953     } catch (...) {
77954       {
77955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77956       };
77957     }
77958   }
77959
77960 }
77961
77962
77963 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewPagePathEffect(void * jarg1) {
77964   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
77965
77966   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
77967   {
77968     try {
77969       delete arg1;
77970     } catch (std::out_of_range& e) {
77971       {
77972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77973       };
77974     } catch (std::exception& e) {
77975       {
77976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77977       };
77978     } catch (Dali::DaliException e) {
77979       {
77980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77981       };
77982     } catch (...) {
77983       {
77984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77985       };
77986     }
77987   }
77988
77989 }
77990
77991
77992 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_x_set(void * jarg1, int jarg2) {
77993   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
77994   Dali::Toolkit::ClampState arg2 ;
77995
77996   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
77997   arg2 = (Dali::Toolkit::ClampState)jarg2;
77998   if (arg1) (arg1)->x = arg2;
77999 }
78000
78001
78002 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_x_get(void * jarg1) {
78003   int jresult ;
78004   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
78005   Dali::Toolkit::ClampState result;
78006
78007   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
78008   result = (Dali::Toolkit::ClampState) ((arg1)->x);
78009   jresult = (int)result;
78010   return jresult;
78011 }
78012
78013
78014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_y_set(void * jarg1, int jarg2) {
78015   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
78016   Dali::Toolkit::ClampState arg2 ;
78017
78018   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
78019   arg2 = (Dali::Toolkit::ClampState)jarg2;
78020   if (arg1) (arg1)->y = arg2;
78021 }
78022
78023
78024 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_y_get(void * jarg1) {
78025   int jresult ;
78026   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
78027   Dali::Toolkit::ClampState result;
78028
78029   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
78030   result = (Dali::Toolkit::ClampState) ((arg1)->y);
78031   jresult = (int)result;
78032   return jresult;
78033 }
78034
78035
78036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ClampState2D() {
78037   void * jresult ;
78038   Dali::Toolkit::ClampState2D *result = 0 ;
78039
78040   {
78041     try {
78042       result = (Dali::Toolkit::ClampState2D *)new Dali::Toolkit::ClampState2D();
78043     } catch (std::out_of_range& e) {
78044       {
78045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78046       };
78047     } catch (std::exception& e) {
78048       {
78049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78050       };
78051     } catch (Dali::DaliException e) {
78052       {
78053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78054       };
78055     } catch (...) {
78056       {
78057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78058       };
78059     }
78060   }
78061
78062   jresult = (void *)result;
78063   return jresult;
78064 }
78065
78066
78067 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ClampState2D(void * jarg1) {
78068   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
78069
78070   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
78071   {
78072     try {
78073       delete arg1;
78074     } catch (std::out_of_range& e) {
78075       {
78076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78077       };
78078     } catch (std::exception& e) {
78079       {
78080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78081       };
78082     } catch (Dali::DaliException e) {
78083       {
78084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78085       };
78086     } catch (...) {
78087       {
78088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78089       };
78090     }
78091   }
78092
78093 }
78094
78095
78096 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_0(float jarg1, float jarg2, unsigned int jarg3) {
78097   void * jresult ;
78098   float arg1 ;
78099   float arg2 ;
78100   bool arg3 ;
78101   Dali::Toolkit::RulerDomain *result = 0 ;
78102
78103   arg1 = (float)jarg1;
78104   arg2 = (float)jarg2;
78105   arg3 = jarg3 ? true : false;
78106   {
78107     try {
78108       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2,arg3);
78109     } catch (std::out_of_range& e) {
78110       {
78111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78112       };
78113     } catch (std::exception& e) {
78114       {
78115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78116       };
78117     } catch (Dali::DaliException e) {
78118       {
78119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78120       };
78121     } catch (...) {
78122       {
78123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78124       };
78125     }
78126   }
78127
78128   jresult = (void *)result;
78129   return jresult;
78130 }
78131
78132
78133 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_1(float jarg1, float jarg2) {
78134   void * jresult ;
78135   float arg1 ;
78136   float arg2 ;
78137   Dali::Toolkit::RulerDomain *result = 0 ;
78138
78139   arg1 = (float)jarg1;
78140   arg2 = (float)jarg2;
78141   {
78142     try {
78143       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2);
78144     } catch (std::out_of_range& e) {
78145       {
78146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78147       };
78148     } catch (std::exception& e) {
78149       {
78150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78151       };
78152     } catch (Dali::DaliException e) {
78153       {
78154         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78155       };
78156     } catch (...) {
78157       {
78158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78159       };
78160     }
78161   }
78162
78163   jresult = (void *)result;
78164   return jresult;
78165 }
78166
78167
78168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_min_set(void * jarg1, float jarg2) {
78169   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78170   float arg2 ;
78171
78172   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78173   arg2 = (float)jarg2;
78174   if (arg1) (arg1)->min = arg2;
78175 }
78176
78177
78178 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_min_get(void * jarg1) {
78179   float jresult ;
78180   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78181   float result;
78182
78183   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78184   result = (float) ((arg1)->min);
78185   jresult = result;
78186   return jresult;
78187 }
78188
78189
78190 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_max_set(void * jarg1, float jarg2) {
78191   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78192   float arg2 ;
78193
78194   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78195   arg2 = (float)jarg2;
78196   if (arg1) (arg1)->max = arg2;
78197 }
78198
78199
78200 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_max_get(void * jarg1) {
78201   float jresult ;
78202   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78203   float result;
78204
78205   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78206   result = (float) ((arg1)->max);
78207   jresult = result;
78208   return jresult;
78209 }
78210
78211
78212 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_set(void * jarg1, unsigned int jarg2) {
78213   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78214   bool arg2 ;
78215
78216   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78217   arg2 = jarg2 ? true : false;
78218   if (arg1) (arg1)->enabled = arg2;
78219 }
78220
78221
78222 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_get(void * jarg1) {
78223   unsigned int jresult ;
78224   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78225   bool result;
78226
78227   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78228   result = (bool) ((arg1)->enabled);
78229   jresult = result;
78230   return jresult;
78231 }
78232
78233
78234 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
78235   float jresult ;
78236   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78237   float arg2 ;
78238   float arg3 ;
78239   float arg4 ;
78240   float result;
78241
78242   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78243   arg2 = (float)jarg2;
78244   arg3 = (float)jarg3;
78245   arg4 = (float)jarg4;
78246   {
78247     try {
78248       result = (float)((Dali::Toolkit::RulerDomain 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_RulerDomain_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
78274   float jresult ;
78275   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78276   float arg2 ;
78277   float arg3 ;
78278   float result;
78279
78280   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78281   arg2 = (float)jarg2;
78282   arg3 = (float)jarg3;
78283   {
78284     try {
78285       result = (float)((Dali::Toolkit::RulerDomain 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_RulerDomain_Clamp__SWIG_2(void * jarg1, float jarg2) {
78311   float jresult ;
78312   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78313   float arg2 ;
78314   float result;
78315
78316   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78317   arg2 = (float)jarg2;
78318   {
78319     try {
78320       result = (float)((Dali::Toolkit::RulerDomain 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_RulerDomain_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
78346   float jresult ;
78347   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78348   float arg2 ;
78349   float arg3 ;
78350   float arg4 ;
78351   Dali::Toolkit::ClampState *arg5 = 0 ;
78352   float result;
78353
78354   arg1 = (Dali::Toolkit::RulerDomain *)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::RulerDomain 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_RulerDomain_GetSize(void * jarg1) {
78391   float jresult ;
78392   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78393   float result;
78394
78395   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78396   {
78397     try {
78398       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->GetSize();
78399     } catch (std::out_of_range& e) {
78400       {
78401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78402       };
78403     } catch (std::exception& e) {
78404       {
78405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78406       };
78407     } catch (Dali::DaliException e) {
78408       {
78409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78410       };
78411     } catch (...) {
78412       {
78413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78414       };
78415     }
78416   }
78417
78418   jresult = result;
78419   return jresult;
78420 }
78421
78422
78423 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerDomain(void * jarg1) {
78424   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78425
78426   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78427   {
78428     try {
78429       delete arg1;
78430     } catch (std::out_of_range& e) {
78431       {
78432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78433       };
78434     } catch (std::exception& e) {
78435       {
78436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78437       };
78438     } catch (Dali::DaliException e) {
78439       {
78440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78441       };
78442     } catch (...) {
78443       {
78444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78445       };
78446     }
78447   }
78448
78449 }
78450
78451
78452 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
78453   float jresult ;
78454   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78455   float arg2 ;
78456   float arg3 ;
78457   float result;
78458
78459   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78460   arg2 = (float)jarg2;
78461   arg3 = (float)jarg3;
78462   {
78463     try {
78464       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2,arg3);
78465     } catch (std::out_of_range& e) {
78466       {
78467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78468       };
78469     } catch (std::exception& e) {
78470       {
78471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78472       };
78473     } catch (Dali::DaliException e) {
78474       {
78475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78476       };
78477     } catch (...) {
78478       {
78479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78480       };
78481     }
78482   }
78483
78484   jresult = result;
78485   return jresult;
78486 }
78487
78488
78489 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_1(void * jarg1, float jarg2) {
78490   float jresult ;
78491   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78492   float arg2 ;
78493   float result;
78494
78495   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78496   arg2 = (float)jarg2;
78497   {
78498     try {
78499       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2);
78500     } catch (std::out_of_range& e) {
78501       {
78502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78503       };
78504     } catch (std::exception& e) {
78505       {
78506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78507       };
78508     } catch (Dali::DaliException e) {
78509       {
78510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78511       };
78512     } catch (...) {
78513       {
78514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78515       };
78516     }
78517   }
78518
78519   jresult = result;
78520   return jresult;
78521 }
78522
78523
78524 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
78525   float jresult ;
78526   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78527   unsigned int arg2 ;
78528   unsigned int *arg3 = 0 ;
78529   bool arg4 ;
78530   float result;
78531
78532   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78533   arg2 = (unsigned int)jarg2;
78534   arg3 = (unsigned int *)jarg3;
78535   arg4 = jarg4 ? true : false;
78536   {
78537     try {
78538       result = (float)((Dali::Toolkit::Ruler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
78539     } catch (std::out_of_range& e) {
78540       {
78541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78542       };
78543     } catch (std::exception& e) {
78544       {
78545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78546       };
78547     } catch (Dali::DaliException e) {
78548       {
78549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78550       };
78551     } catch (...) {
78552       {
78553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78554       };
78555     }
78556   }
78557
78558   jresult = result;
78559   return jresult;
78560 }
78561
78562
78563 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
78564   unsigned int jresult ;
78565   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78566   float arg2 ;
78567   bool arg3 ;
78568   unsigned int result;
78569
78570   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78571   arg2 = (float)jarg2;
78572   arg3 = jarg3 ? true : false;
78573   {
78574     try {
78575       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetPageFromPosition(arg2,arg3);
78576     } catch (std::out_of_range& e) {
78577       {
78578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78579       };
78580     } catch (std::exception& e) {
78581       {
78582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78583       };
78584     } catch (Dali::DaliException e) {
78585       {
78586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78587       };
78588     } catch (...) {
78589       {
78590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78591       };
78592     }
78593   }
78594
78595   jresult = result;
78596   return jresult;
78597 }
78598
78599
78600 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetTotalPages(void * jarg1) {
78601   unsigned int jresult ;
78602   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78603   unsigned int result;
78604
78605   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78606   {
78607     try {
78608       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetTotalPages();
78609     } catch (std::out_of_range& e) {
78610       {
78611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78612       };
78613     } catch (std::exception& e) {
78614       {
78615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78616       };
78617     } catch (Dali::DaliException e) {
78618       {
78619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78620       };
78621     } catch (...) {
78622       {
78623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78624       };
78625     }
78626   }
78627
78628   jresult = result;
78629   return jresult;
78630 }
78631
78632
78633 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Ruler_GetType(void * jarg1) {
78634   int jresult ;
78635   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78636   Dali::Toolkit::Ruler::RulerType result;
78637
78638   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78639   {
78640     try {
78641       result = (Dali::Toolkit::Ruler::RulerType)((Dali::Toolkit::Ruler const *)arg1)->GetType();
78642     } catch (std::out_of_range& e) {
78643       {
78644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78645       };
78646     } catch (std::exception& e) {
78647       {
78648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78649       };
78650     } catch (Dali::DaliException e) {
78651       {
78652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78653       };
78654     } catch (...) {
78655       {
78656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78657       };
78658     }
78659   }
78660
78661   jresult = (int)result;
78662   return jresult;
78663 }
78664
78665
78666 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_IsEnabled(void * jarg1) {
78667   unsigned int jresult ;
78668   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78669   bool result;
78670
78671   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78672   {
78673     try {
78674       result = (bool)((Dali::Toolkit::Ruler const *)arg1)->IsEnabled();
78675     } catch (std::out_of_range& e) {
78676       {
78677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78678       };
78679     } catch (std::exception& e) {
78680       {
78681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78682       };
78683     } catch (Dali::DaliException e) {
78684       {
78685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78686       };
78687     } catch (...) {
78688       {
78689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78690       };
78691     }
78692   }
78693
78694   jresult = result;
78695   return jresult;
78696 }
78697
78698
78699 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Enable(void * jarg1) {
78700   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78701
78702   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78703   {
78704     try {
78705       (arg1)->Enable();
78706     } catch (std::out_of_range& e) {
78707       {
78708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78709       };
78710     } catch (std::exception& e) {
78711       {
78712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78713       };
78714     } catch (Dali::DaliException e) {
78715       {
78716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78717       };
78718     } catch (...) {
78719       {
78720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78721       };
78722     }
78723   }
78724
78725 }
78726
78727
78728 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Disable(void * jarg1) {
78729   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78730
78731   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78732   {
78733     try {
78734       (arg1)->Disable();
78735     } catch (std::out_of_range& e) {
78736       {
78737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78738       };
78739     } catch (std::exception& e) {
78740       {
78741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78742       };
78743     } catch (Dali::DaliException e) {
78744       {
78745         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78746       };
78747     } catch (...) {
78748       {
78749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78750       };
78751     }
78752   }
78753
78754 }
78755
78756
78757 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_SetDomain(void * jarg1, void * jarg2) {
78758   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78759   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
78760   Dali::Toolkit::RulerDomain *argp2 ;
78761
78762   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78763   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
78764   if (!argp2) {
78765     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
78766     return ;
78767   }
78768   arg2 = *argp2;
78769   {
78770     try {
78771       (arg1)->SetDomain(arg2);
78772     } catch (std::out_of_range& e) {
78773       {
78774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78775       };
78776     } catch (std::exception& e) {
78777       {
78778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78779       };
78780     } catch (Dali::DaliException e) {
78781       {
78782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78783       };
78784     } catch (...) {
78785       {
78786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78787       };
78788     }
78789   }
78790
78791 }
78792
78793
78794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Ruler_GetDomain(void * jarg1) {
78795   void * jresult ;
78796   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78797   Dali::Toolkit::RulerDomain *result = 0 ;
78798
78799   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78800   {
78801     try {
78802       result = (Dali::Toolkit::RulerDomain *) &((Dali::Toolkit::Ruler const *)arg1)->GetDomain();
78803     } catch (std::out_of_range& e) {
78804       {
78805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78806       };
78807     } catch (std::exception& e) {
78808       {
78809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78810       };
78811     } catch (Dali::DaliException e) {
78812       {
78813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78814       };
78815     } catch (...) {
78816       {
78817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78818       };
78819     }
78820   }
78821
78822   jresult = (void *)result;
78823   return jresult;
78824 }
78825
78826
78827 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_DisableDomain(void * jarg1) {
78828   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78829
78830   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78831   {
78832     try {
78833       (arg1)->DisableDomain();
78834     } catch (std::out_of_range& e) {
78835       {
78836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78837       };
78838     } catch (std::exception& e) {
78839       {
78840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78841       };
78842     } catch (Dali::DaliException e) {
78843       {
78844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78845       };
78846     } catch (...) {
78847       {
78848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78849       };
78850     }
78851   }
78852
78853 }
78854
78855
78856 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
78857   float jresult ;
78858   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78859   float arg2 ;
78860   float arg3 ;
78861   float arg4 ;
78862   float result;
78863
78864   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78865   arg2 = (float)jarg2;
78866   arg3 = (float)jarg3;
78867   arg4 = (float)jarg4;
78868   {
78869     try {
78870       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4);
78871     } catch (std::out_of_range& e) {
78872       {
78873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78874       };
78875     } catch (std::exception& e) {
78876       {
78877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78878       };
78879     } catch (Dali::DaliException e) {
78880       {
78881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78882       };
78883     } catch (...) {
78884       {
78885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78886       };
78887     }
78888   }
78889
78890   jresult = result;
78891   return jresult;
78892 }
78893
78894
78895 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
78896   float jresult ;
78897   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78898   float arg2 ;
78899   float arg3 ;
78900   float result;
78901
78902   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78903   arg2 = (float)jarg2;
78904   arg3 = (float)jarg3;
78905   {
78906     try {
78907       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3);
78908     } catch (std::out_of_range& e) {
78909       {
78910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78911       };
78912     } catch (std::exception& e) {
78913       {
78914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78915       };
78916     } catch (Dali::DaliException e) {
78917       {
78918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78919       };
78920     } catch (...) {
78921       {
78922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78923       };
78924     }
78925   }
78926
78927   jresult = result;
78928   return jresult;
78929 }
78930
78931
78932 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_2(void * jarg1, float jarg2) {
78933   float jresult ;
78934   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78935   float arg2 ;
78936   float result;
78937
78938   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78939   arg2 = (float)jarg2;
78940   {
78941     try {
78942       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2);
78943     } catch (std::out_of_range& e) {
78944       {
78945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78946       };
78947     } catch (std::exception& e) {
78948       {
78949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78950       };
78951     } catch (Dali::DaliException e) {
78952       {
78953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78954       };
78955     } catch (...) {
78956       {
78957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78958       };
78959     }
78960   }
78961
78962   jresult = result;
78963   return jresult;
78964 }
78965
78966
78967 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
78968   float jresult ;
78969   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78970   float arg2 ;
78971   float arg3 ;
78972   float arg4 ;
78973   Dali::Toolkit::ClampState *arg5 = 0 ;
78974   float result;
78975
78976   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78977   arg2 = (float)jarg2;
78978   arg3 = (float)jarg3;
78979   arg4 = (float)jarg4;
78980   arg5 = (Dali::Toolkit::ClampState *)jarg5;
78981   if (!arg5) {
78982     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
78983     return 0;
78984   }
78985   {
78986     try {
78987       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
78988     } catch (std::out_of_range& e) {
78989       {
78990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78991       };
78992     } catch (std::exception& e) {
78993       {
78994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78995       };
78996     } catch (Dali::DaliException e) {
78997       {
78998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78999       };
79000     } catch (...) {
79001       {
79002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79003       };
79004     }
79005   }
79006
79007   jresult = result;
79008   return jresult;
79009 }
79010
79011
79012 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
79013   float jresult ;
79014   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
79015   float arg2 ;
79016   float arg3 ;
79017   float arg4 ;
79018   float arg5 ;
79019   float result;
79020
79021   arg1 = (Dali::Toolkit::Ruler *)jarg1;
79022   arg2 = (float)jarg2;
79023   arg3 = (float)jarg3;
79024   arg4 = (float)jarg4;
79025   arg5 = (float)jarg5;
79026   {
79027     try {
79028       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
79029     } catch (std::out_of_range& e) {
79030       {
79031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79032       };
79033     } catch (std::exception& e) {
79034       {
79035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79036       };
79037     } catch (Dali::DaliException e) {
79038       {
79039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79040       };
79041     } catch (...) {
79042       {
79043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79044       };
79045     }
79046   }
79047
79048   jresult = result;
79049   return jresult;
79050 }
79051
79052
79053 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
79054   float jresult ;
79055   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
79056   float arg2 ;
79057   float arg3 ;
79058   float arg4 ;
79059   float result;
79060
79061   arg1 = (Dali::Toolkit::Ruler *)jarg1;
79062   arg2 = (float)jarg2;
79063   arg3 = (float)jarg3;
79064   arg4 = (float)jarg4;
79065   {
79066     try {
79067       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4);
79068     } catch (std::out_of_range& e) {
79069       {
79070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79071       };
79072     } catch (std::exception& e) {
79073       {
79074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79075       };
79076     } catch (Dali::DaliException e) {
79077       {
79078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79079       };
79080     } catch (...) {
79081       {
79082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79083       };
79084     }
79085   }
79086
79087   jresult = result;
79088   return jresult;
79089 }
79090
79091
79092 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
79093   float jresult ;
79094   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
79095   float arg2 ;
79096   float arg3 ;
79097   float result;
79098
79099   arg1 = (Dali::Toolkit::Ruler *)jarg1;
79100   arg2 = (float)jarg2;
79101   arg3 = (float)jarg3;
79102   {
79103     try {
79104       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3);
79105     } catch (std::out_of_range& e) {
79106       {
79107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79108       };
79109     } catch (std::exception& e) {
79110       {
79111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79112       };
79113     } catch (Dali::DaliException e) {
79114       {
79115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79116       };
79117     } catch (...) {
79118       {
79119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79120       };
79121     }
79122   }
79123
79124   jresult = result;
79125   return jresult;
79126 }
79127
79128
79129 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
79130   float jresult ;
79131   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
79132   float arg2 ;
79133   float result;
79134
79135   arg1 = (Dali::Toolkit::Ruler *)jarg1;
79136   arg2 = (float)jarg2;
79137   {
79138     try {
79139       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2);
79140     } catch (std::out_of_range& e) {
79141       {
79142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79143       };
79144     } catch (std::exception& e) {
79145       {
79146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79147       };
79148     } catch (Dali::DaliException e) {
79149       {
79150         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79151       };
79152     } catch (...) {
79153       {
79154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79155       };
79156     }
79157   }
79158
79159   jresult = result;
79160   return jresult;
79161 }
79162
79163
79164 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
79165   float jresult ;
79166   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
79167   float arg2 ;
79168   float arg3 ;
79169   float arg4 ;
79170   float arg5 ;
79171   Dali::Toolkit::ClampState *arg6 = 0 ;
79172   float result;
79173
79174   arg1 = (Dali::Toolkit::Ruler *)jarg1;
79175   arg2 = (float)jarg2;
79176   arg3 = (float)jarg3;
79177   arg4 = (float)jarg4;
79178   arg5 = (float)jarg5;
79179   arg6 = (Dali::Toolkit::ClampState *)jarg6;
79180   if (!arg6) {
79181     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
79182     return 0;
79183   }
79184   {
79185     try {
79186       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
79187     } catch (std::out_of_range& e) {
79188       {
79189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79190       };
79191     } catch (std::exception& e) {
79192       {
79193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79194       };
79195     } catch (Dali::DaliException e) {
79196       {
79197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79198       };
79199     } catch (...) {
79200       {
79201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79202       };
79203     }
79204   }
79205
79206   jresult = result;
79207   return jresult;
79208 }
79209
79210
79211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DefaultRuler() {
79212   void * jresult ;
79213   Dali::Toolkit::DefaultRuler *result = 0 ;
79214
79215   {
79216     try {
79217       result = (Dali::Toolkit::DefaultRuler *)new Dali::Toolkit::DefaultRuler();
79218     } catch (std::out_of_range& e) {
79219       {
79220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79221       };
79222     } catch (std::exception& e) {
79223       {
79224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79225       };
79226     } catch (Dali::DaliException e) {
79227       {
79228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79229       };
79230     } catch (...) {
79231       {
79232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79233       };
79234     }
79235   }
79236
79237   jresult = (void *)result;
79238   return jresult;
79239 }
79240
79241
79242 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_Snap(void * jarg1, float jarg2, float jarg3) {
79243   float jresult ;
79244   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
79245   float arg2 ;
79246   float arg3 ;
79247   float result;
79248
79249   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
79250   arg2 = (float)jarg2;
79251   arg3 = (float)jarg3;
79252   {
79253     try {
79254       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->Snap(arg2,arg3);
79255     } catch (std::out_of_range& e) {
79256       {
79257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79258       };
79259     } catch (std::exception& e) {
79260       {
79261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79262       };
79263     } catch (Dali::DaliException e) {
79264       {
79265         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79266       };
79267     } catch (...) {
79268       {
79269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79270       };
79271     }
79272   }
79273
79274   jresult = result;
79275   return jresult;
79276 }
79277
79278
79279 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
79280   float jresult ;
79281   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
79282   unsigned int arg2 ;
79283   unsigned int *arg3 = 0 ;
79284   bool arg4 ;
79285   float result;
79286
79287   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
79288   arg2 = (unsigned int)jarg2;
79289   arg3 = (unsigned int *)jarg3;
79290   arg4 = jarg4 ? true : false;
79291   {
79292     try {
79293       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
79294     } catch (std::out_of_range& e) {
79295       {
79296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79297       };
79298     } catch (std::exception& e) {
79299       {
79300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79301       };
79302     } catch (Dali::DaliException e) {
79303       {
79304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79305       };
79306     } catch (...) {
79307       {
79308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79309       };
79310     }
79311   }
79312
79313   jresult = result;
79314   return jresult;
79315 }
79316
79317
79318 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
79319   unsigned int jresult ;
79320   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
79321   float arg2 ;
79322   bool arg3 ;
79323   unsigned int result;
79324
79325   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
79326   arg2 = (float)jarg2;
79327   arg3 = jarg3 ? true : false;
79328   {
79329     try {
79330       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
79331     } catch (std::out_of_range& e) {
79332       {
79333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79334       };
79335     } catch (std::exception& e) {
79336       {
79337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79338       };
79339     } catch (Dali::DaliException e) {
79340       {
79341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79342       };
79343     } catch (...) {
79344       {
79345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79346       };
79347     }
79348   }
79349
79350   jresult = result;
79351   return jresult;
79352 }
79353
79354
79355 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetTotalPages(void * jarg1) {
79356   unsigned int jresult ;
79357   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
79358   unsigned int result;
79359
79360   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
79361   {
79362     try {
79363       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetTotalPages();
79364     } catch (std::out_of_range& e) {
79365       {
79366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79367       };
79368     } catch (std::exception& e) {
79369       {
79370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79371       };
79372     } catch (Dali::DaliException e) {
79373       {
79374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79375       };
79376     } catch (...) {
79377       {
79378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79379       };
79380     }
79381   }
79382
79383   jresult = result;
79384   return jresult;
79385 }
79386
79387
79388 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DefaultRuler(void * jarg1) {
79389   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
79390
79391   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
79392   {
79393     try {
79394       delete arg1;
79395     } catch (std::out_of_range& e) {
79396       {
79397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79398       };
79399     } catch (std::exception& e) {
79400       {
79401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79402       };
79403     } catch (Dali::DaliException e) {
79404       {
79405         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79406       };
79407     } catch (...) {
79408       {
79409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79410       };
79411     }
79412   }
79413
79414 }
79415
79416
79417 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_0(float jarg1) {
79418   void * jresult ;
79419   float arg1 ;
79420   Dali::Toolkit::FixedRuler *result = 0 ;
79421
79422   arg1 = (float)jarg1;
79423   {
79424     try {
79425       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler(arg1);
79426     } catch (std::out_of_range& e) {
79427       {
79428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79429       };
79430     } catch (std::exception& e) {
79431       {
79432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79433       };
79434     } catch (Dali::DaliException e) {
79435       {
79436         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79437       };
79438     } catch (...) {
79439       {
79440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79441       };
79442     }
79443   }
79444
79445   jresult = (void *)result;
79446   return jresult;
79447 }
79448
79449
79450 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_1() {
79451   void * jresult ;
79452   Dali::Toolkit::FixedRuler *result = 0 ;
79453
79454   {
79455     try {
79456       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler();
79457     } catch (std::out_of_range& e) {
79458       {
79459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79460       };
79461     } catch (std::exception& e) {
79462       {
79463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79464       };
79465     } catch (Dali::DaliException e) {
79466       {
79467         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79468       };
79469     } catch (...) {
79470       {
79471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79472       };
79473     }
79474   }
79475
79476   jresult = (void *)result;
79477   return jresult;
79478 }
79479
79480
79481 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_Snap(void * jarg1, float jarg2, float jarg3) {
79482   float jresult ;
79483   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79484   float arg2 ;
79485   float arg3 ;
79486   float result;
79487
79488   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79489   arg2 = (float)jarg2;
79490   arg3 = (float)jarg3;
79491   {
79492     try {
79493       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->Snap(arg2,arg3);
79494     } catch (std::out_of_range& e) {
79495       {
79496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79497       };
79498     } catch (std::exception& e) {
79499       {
79500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79501       };
79502     } catch (Dali::DaliException e) {
79503       {
79504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79505       };
79506     } catch (...) {
79507       {
79508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79509       };
79510     }
79511   }
79512
79513   jresult = result;
79514   return jresult;
79515 }
79516
79517
79518 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
79519   float jresult ;
79520   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79521   unsigned int arg2 ;
79522   unsigned int *arg3 = 0 ;
79523   bool arg4 ;
79524   float result;
79525
79526   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79527   arg2 = (unsigned int)jarg2;
79528   arg3 = (unsigned int *)jarg3;
79529   arg4 = jarg4 ? true : false;
79530   {
79531     try {
79532       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
79533     } catch (std::out_of_range& e) {
79534       {
79535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79536       };
79537     } catch (std::exception& e) {
79538       {
79539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79540       };
79541     } catch (Dali::DaliException e) {
79542       {
79543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79544       };
79545     } catch (...) {
79546       {
79547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79548       };
79549     }
79550   }
79551
79552   jresult = result;
79553   return jresult;
79554 }
79555
79556
79557 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
79558   unsigned int jresult ;
79559   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79560   float arg2 ;
79561   bool arg3 ;
79562   unsigned int result;
79563
79564   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79565   arg2 = (float)jarg2;
79566   arg3 = jarg3 ? true : false;
79567   {
79568     try {
79569       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
79570     } catch (std::out_of_range& e) {
79571       {
79572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79573       };
79574     } catch (std::exception& e) {
79575       {
79576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79577       };
79578     } catch (Dali::DaliException e) {
79579       {
79580         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79581       };
79582     } catch (...) {
79583       {
79584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79585       };
79586     }
79587   }
79588
79589   jresult = result;
79590   return jresult;
79591 }
79592
79593
79594 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetTotalPages(void * jarg1) {
79595   unsigned int jresult ;
79596   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79597   unsigned int result;
79598
79599   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79600   {
79601     try {
79602       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetTotalPages();
79603     } catch (std::out_of_range& e) {
79604       {
79605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79606       };
79607     } catch (std::exception& e) {
79608       {
79609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79610       };
79611     } catch (Dali::DaliException e) {
79612       {
79613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79614       };
79615     } catch (...) {
79616       {
79617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79618       };
79619     }
79620   }
79621
79622   jresult = result;
79623   return jresult;
79624 }
79625
79626
79627 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FixedRuler(void * jarg1) {
79628   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79629
79630   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79631   {
79632     try {
79633       delete arg1;
79634     } catch (std::out_of_range& e) {
79635       {
79636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79637       };
79638     } catch (std::exception& e) {
79639       {
79640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79641       };
79642     } catch (Dali::DaliException e) {
79643       {
79644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79645       };
79646     } catch (...) {
79647       {
79648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79649       };
79650     }
79651   }
79652
79653 }
79654
79655
79656 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_set(void * jarg1, void * jarg2) {
79657   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79658   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
79659
79660   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79661   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
79662   if (arg1) (arg1)->scale = *arg2;
79663 }
79664
79665
79666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_get(void * jarg1) {
79667   void * jresult ;
79668   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79669   Dali::Toolkit::ClampState2D *result = 0 ;
79670
79671   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79672   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->scale);
79673   jresult = (void *)result;
79674   return jresult;
79675 }
79676
79677
79678 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_set(void * jarg1, void * jarg2) {
79679   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79680   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
79681
79682   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79683   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
79684   if (arg1) (arg1)->position = *arg2;
79685 }
79686
79687
79688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_get(void * jarg1) {
79689   void * jresult ;
79690   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79691   Dali::Toolkit::ClampState2D *result = 0 ;
79692
79693   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79694   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->position);
79695   jresult = (void *)result;
79696   return jresult;
79697 }
79698
79699
79700 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_set(void * jarg1, int jarg2) {
79701   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79702   Dali::Toolkit::ClampState arg2 ;
79703
79704   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79705   arg2 = (Dali::Toolkit::ClampState)jarg2;
79706   if (arg1) (arg1)->rotation = arg2;
79707 }
79708
79709
79710 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_get(void * jarg1) {
79711   int jresult ;
79712   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79713   Dali::Toolkit::ClampState result;
79714
79715   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79716   result = (Dali::Toolkit::ClampState) ((arg1)->rotation);
79717   jresult = (int)result;
79718   return jresult;
79719 }
79720
79721
79722 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_ClampEvent() {
79723   void * jresult ;
79724   Dali::Toolkit::ScrollView::ClampEvent *result = 0 ;
79725
79726   {
79727     try {
79728       result = (Dali::Toolkit::ScrollView::ClampEvent *)new Dali::Toolkit::ScrollView::ClampEvent();
79729     } catch (std::out_of_range& e) {
79730       {
79731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79732       };
79733     } catch (std::exception& e) {
79734       {
79735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79736       };
79737     } catch (Dali::DaliException e) {
79738       {
79739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79740       };
79741     } catch (...) {
79742       {
79743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79744       };
79745     }
79746   }
79747
79748   jresult = (void *)result;
79749   return jresult;
79750 }
79751
79752
79753 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_ClampEvent(void * jarg1) {
79754   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79755
79756   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79757   {
79758     try {
79759       delete arg1;
79760     } catch (std::out_of_range& e) {
79761       {
79762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79763       };
79764     } catch (std::exception& e) {
79765       {
79766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79767       };
79768     } catch (Dali::DaliException e) {
79769       {
79770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79771       };
79772     } catch (...) {
79773       {
79774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79775       };
79776     }
79777   }
79778
79779 }
79780
79781
79782 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_set(void * jarg1, int jarg2) {
79783   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79784   Dali::Toolkit::SnapType arg2 ;
79785
79786   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79787   arg2 = (Dali::Toolkit::SnapType)jarg2;
79788   if (arg1) (arg1)->type = arg2;
79789 }
79790
79791
79792 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_get(void * jarg1) {
79793   int jresult ;
79794   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79795   Dali::Toolkit::SnapType result;
79796
79797   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79798   result = (Dali::Toolkit::SnapType) ((arg1)->type);
79799   jresult = (int)result;
79800   return jresult;
79801 }
79802
79803
79804 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_set(void * jarg1, void * jarg2) {
79805   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79806   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
79807
79808   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79809   arg2 = (Dali::Vector2 *)jarg2;
79810   if (arg1) (arg1)->position = *arg2;
79811 }
79812
79813
79814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_get(void * jarg1) {
79815   void * jresult ;
79816   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79817   Dali::Vector2 *result = 0 ;
79818
79819   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79820   result = (Dali::Vector2 *)& ((arg1)->position);
79821   jresult = (void *)result;
79822   return jresult;
79823 }
79824
79825
79826 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_set(void * jarg1, float jarg2) {
79827   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79828   float arg2 ;
79829
79830   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79831   arg2 = (float)jarg2;
79832   if (arg1) (arg1)->duration = arg2;
79833 }
79834
79835
79836 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_get(void * jarg1) {
79837   float jresult ;
79838   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79839   float result;
79840
79841   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79842   result = (float) ((arg1)->duration);
79843   jresult = result;
79844   return jresult;
79845 }
79846
79847
79848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_SnapEvent() {
79849   void * jresult ;
79850   Dali::Toolkit::ScrollView::SnapEvent *result = 0 ;
79851
79852   {
79853     try {
79854       result = (Dali::Toolkit::ScrollView::SnapEvent *)new Dali::Toolkit::ScrollView::SnapEvent();
79855     } catch (std::out_of_range& e) {
79856       {
79857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79858       };
79859     } catch (std::exception& e) {
79860       {
79861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79862       };
79863     } catch (Dali::DaliException e) {
79864       {
79865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79866       };
79867     } catch (...) {
79868       {
79869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79870       };
79871     }
79872   }
79873
79874   jresult = (void *)result;
79875   return jresult;
79876 }
79877
79878
79879 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_SnapEvent(void * jarg1) {
79880   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79881
79882   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79883   {
79884     try {
79885       delete arg1;
79886     } catch (std::out_of_range& e) {
79887       {
79888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79889       };
79890     } catch (std::exception& e) {
79891       {
79892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79893       };
79894     } catch (Dali::DaliException e) {
79895       {
79896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79897       };
79898     } catch (...) {
79899       {
79900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79901       };
79902     }
79903   }
79904
79905 }
79906
79907
79908 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_ENABLED_get() {
79909   int jresult ;
79910   int result;
79911
79912   result = (int)Dali::Toolkit::ScrollView::Property::WRAP_ENABLED;
79913   jresult = (int)result;
79914   return jresult;
79915 }
79916
79917
79918 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_ENABLED_get() {
79919   int jresult ;
79920   int result;
79921
79922   result = (int)Dali::Toolkit::ScrollView::Property::PANNING_ENABLED;
79923   jresult = (int)result;
79924   return jresult;
79925 }
79926
79927
79928 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_AXIS_AUTO_LOCK_ENABLED_get() {
79929   int jresult ;
79930   int result;
79931
79932   result = (int)Dali::Toolkit::ScrollView::Property::AXIS_AUTO_LOCK_ENABLED;
79933   jresult = (int)result;
79934   return jresult;
79935 }
79936
79937
79938 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
79939   int jresult ;
79940   int result;
79941
79942   result = (int)Dali::Toolkit::ScrollView::Property::WHEEL_SCROLL_DISTANCE_STEP;
79943   jresult = (int)result;
79944   return jresult;
79945 }
79946
79947
79948 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_MODE_get() {
79949   int jresult ;
79950   int result;
79951
79952   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_MODE;
79953   jresult = (int)result;
79954   return jresult;
79955 }
79956
79957 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_get() {
79958   int jresult ;
79959   int result;
79960
79961   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION;
79962   jresult = (int)result;
79963   return jresult;
79964 }
79965
79966
79967 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_get() {
79968   int jresult ;
79969   int result;
79970
79971   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION;
79972   jresult = (int)result;
79973   return jresult;
79974 }
79975
79976
79977 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_X_get() {
79978   int jresult ;
79979   int result;
79980
79981   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_X;
79982   jresult = (int)result;
79983   return jresult;
79984 }
79985
79986
79987 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_Y_get() {
79988   int jresult ;
79989   int result;
79990
79991   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_Y;
79992   jresult = (int)result;
79993   return jresult;
79994 }
79995
79996
79997 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_get() {
79998   int jresult ;
79999   int result;
80000
80001   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX;
80002   jresult = (int)result;
80003   return jresult;
80004 }
80005
80006
80007 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_X_get() {
80008   int jresult ;
80009   int result;
80010
80011   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_X;
80012   jresult = (int)result;
80013   return jresult;
80014 }
80015
80016
80017 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_Y_get() {
80018   int jresult ;
80019   int result;
80020
80021   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_Y;
80022   jresult = (int)result;
80023   return jresult;
80024 }
80025
80026
80027 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_X_get() {
80028   int jresult ;
80029   int result;
80030
80031   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_X;
80032   jresult = (int)result;
80033   return jresult;
80034 }
80035
80036
80037 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_Y_get() {
80038   int jresult ;
80039   int result;
80040
80041   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_Y;
80042   jresult = (int)result;
80043   return jresult;
80044 }
80045
80046
80047 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_get() {
80048   int jresult ;
80049   int result;
80050
80051   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL;
80052   jresult = (int)result;
80053   return jresult;
80054 }
80055
80056
80057 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_X_get() {
80058   int jresult ;
80059   int result;
80060
80061   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_X;
80062   jresult = (int)result;
80063   return jresult;
80064 }
80065
80066
80067 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_Y_get() {
80068   int jresult ;
80069   int result;
80070
80071   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_Y;
80072   jresult = (int)result;
80073   return jresult;
80074 }
80075
80076
80077 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_get() {
80078   int jresult ;
80079   int result;
80080
80081   result = (int)Dali::Toolkit::ScrollView::Property::WRAP;
80082   jresult = (int)result;
80083   return jresult;
80084 }
80085
80086
80087 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_get() {
80088   int jresult ;
80089   int result;
80090
80091   result = (int)Dali::Toolkit::ScrollView::Property::PANNING;
80092   jresult = (int)result;
80093   return jresult;
80094 }
80095
80096
80097 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLLING_get() {
80098   int jresult ;
80099   int result;
80100
80101   result = (int)Dali::Toolkit::ScrollView::Property::SCROLLING;
80102   jresult = (int)result;
80103   return jresult;
80104 }
80105
80106
80107 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_get() {
80108   int jresult ;
80109   int result;
80110
80111   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE;
80112   jresult = (int)result;
80113   return jresult;
80114 }
80115
80116
80117 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_X_get() {
80118   int jresult ;
80119   int result;
80120
80121   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_X;
80122   jresult = (int)result;
80123   return jresult;
80124 }
80125
80126
80127 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_Y_get() {
80128   int jresult ;
80129   int result;
80130
80131   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_Y;
80132   jresult = (int)result;
80133   return jresult;
80134 }
80135
80136
80137 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_OFFSET_get() {
80138   int jresult ;
80139   int result;
80140
80141   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_OFFSET;
80142   jresult = (int)result;
80143   return jresult;
80144 }
80145
80146
80147 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_DELTA_get() {
80148   int jresult ;
80149   int result;
80150
80151   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION_DELTA;
80152   jresult = (int)result;
80153   return jresult;
80154 }
80155
80156
80157 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_START_PAGE_POSITION_get() {
80158   int jresult ;
80159   int result;
80160
80161   result = (int)Dali::Toolkit::ScrollView::Property::START_PAGE_POSITION;
80162   jresult = (int)result;
80163   return jresult;
80164 }
80165
80166
80167 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_Property() {
80168   void * jresult ;
80169   Dali::Toolkit::ScrollView::Property *result = 0 ;
80170
80171   {
80172     try {
80173       result = (Dali::Toolkit::ScrollView::Property *)new Dali::Toolkit::ScrollView::Property();
80174     } catch (std::out_of_range& e) {
80175       {
80176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80177       };
80178     } catch (std::exception& e) {
80179       {
80180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80181       };
80182     } catch (Dali::DaliException e) {
80183       {
80184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80185       };
80186     } catch (...) {
80187       {
80188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80189       };
80190     }
80191   }
80192
80193   jresult = (void *)result;
80194   return jresult;
80195 }
80196
80197
80198 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_Property(void * jarg1) {
80199   Dali::Toolkit::ScrollView::Property *arg1 = (Dali::Toolkit::ScrollView::Property *) 0 ;
80200
80201   arg1 = (Dali::Toolkit::ScrollView::Property *)jarg1;
80202   {
80203     try {
80204       delete arg1;
80205     } catch (std::out_of_range& e) {
80206       {
80207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80208       };
80209     } catch (std::exception& e) {
80210       {
80211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80212       };
80213     } catch (Dali::DaliException e) {
80214       {
80215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80216       };
80217     } catch (...) {
80218       {
80219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80220       };
80221     }
80222   }
80223
80224 }
80225
80226
80227 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_0() {
80228   void * jresult ;
80229   Dali::Toolkit::ScrollView *result = 0 ;
80230
80231   {
80232     try {
80233       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView();
80234     } catch (std::out_of_range& e) {
80235       {
80236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80237       };
80238     } catch (std::exception& e) {
80239       {
80240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80241       };
80242     } catch (Dali::DaliException e) {
80243       {
80244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80245       };
80246     } catch (...) {
80247       {
80248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80249       };
80250     }
80251   }
80252
80253   jresult = (void *)result;
80254   return jresult;
80255 }
80256
80257
80258 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_1(void * jarg1) {
80259   void * jresult ;
80260   Dali::Toolkit::ScrollView *arg1 = 0 ;
80261   Dali::Toolkit::ScrollView *result = 0 ;
80262
80263   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80264   if (!arg1) {
80265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
80266     return 0;
80267   }
80268   {
80269     try {
80270       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView((Dali::Toolkit::ScrollView const &)*arg1);
80271     } catch (std::out_of_range& e) {
80272       {
80273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80274       };
80275     } catch (std::exception& e) {
80276       {
80277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80278       };
80279     } catch (Dali::DaliException e) {
80280       {
80281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80282       };
80283     } catch (...) {
80284       {
80285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80286       };
80287     }
80288   }
80289
80290   jresult = (void *)result;
80291   return jresult;
80292 }
80293
80294
80295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_Assign(void * jarg1, void * jarg2) {
80296   void * jresult ;
80297   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80298   Dali::Toolkit::ScrollView *arg2 = 0 ;
80299   Dali::Toolkit::ScrollView *result = 0 ;
80300
80301   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80302   arg2 = (Dali::Toolkit::ScrollView *)jarg2;
80303   if (!arg2) {
80304     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
80305     return 0;
80306   }
80307   {
80308     try {
80309       result = (Dali::Toolkit::ScrollView *) &(arg1)->operator =((Dali::Toolkit::ScrollView const &)*arg2);
80310     } catch (std::out_of_range& e) {
80311       {
80312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80313       };
80314     } catch (std::exception& e) {
80315       {
80316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80317       };
80318     } catch (Dali::DaliException e) {
80319       {
80320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80321       };
80322     } catch (...) {
80323       {
80324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80325       };
80326     }
80327   }
80328
80329   jresult = (void *)result;
80330   return jresult;
80331 }
80332
80333
80334 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView(void * jarg1) {
80335   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80336
80337   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80338   {
80339     try {
80340       delete arg1;
80341     } catch (std::out_of_range& e) {
80342       {
80343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80344       };
80345     } catch (std::exception& e) {
80346       {
80347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80348       };
80349     } catch (Dali::DaliException e) {
80350       {
80351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80352       };
80353     } catch (...) {
80354       {
80355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80356       };
80357     }
80358   }
80359
80360 }
80361
80362
80363 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_New() {
80364   void * jresult ;
80365   Dali::Toolkit::ScrollView result;
80366
80367   {
80368     try {
80369       result = Dali::Toolkit::ScrollView::New();
80370     } catch (std::out_of_range& e) {
80371       {
80372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80373       };
80374     } catch (std::exception& e) {
80375       {
80376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80377       };
80378     } catch (Dali::DaliException e) {
80379       {
80380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80381       };
80382     } catch (...) {
80383       {
80384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80385       };
80386     }
80387   }
80388
80389   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
80390   return jresult;
80391 }
80392
80393
80394 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_DownCast(void * jarg1) {
80395   void * jresult ;
80396   Dali::BaseHandle arg1 ;
80397   Dali::BaseHandle *argp1 ;
80398   Dali::Toolkit::ScrollView result;
80399
80400   argp1 = (Dali::BaseHandle *)jarg1;
80401   if (!argp1) {
80402     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
80403     return 0;
80404   }
80405   arg1 = *argp1;
80406   {
80407     try {
80408       result = Dali::Toolkit::ScrollView::DownCast(arg1);
80409     } catch (std::out_of_range& e) {
80410       {
80411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80412       };
80413     } catch (std::exception& e) {
80414       {
80415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80416       };
80417     } catch (Dali::DaliException e) {
80418       {
80419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80420       };
80421     } catch (...) {
80422       {
80423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80424       };
80425     }
80426   }
80427
80428   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
80429   return jresult;
80430 }
80431
80432
80433 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapAlphaFunction(void * jarg1) {
80434   void * jresult ;
80435   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80436   Dali::AlphaFunction result;
80437
80438   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80439   {
80440     try {
80441       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapAlphaFunction();
80442     } catch (std::out_of_range& e) {
80443       {
80444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80445       };
80446     } catch (std::exception& e) {
80447       {
80448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80449       };
80450     } catch (Dali::DaliException e) {
80451       {
80452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80453       };
80454     } catch (...) {
80455       {
80456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80457       };
80458     }
80459   }
80460
80461   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
80462   return jresult;
80463 }
80464
80465
80466 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapAlphaFunction(void * jarg1, void * jarg2) {
80467   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80468   Dali::AlphaFunction arg2 ;
80469   Dali::AlphaFunction *argp2 ;
80470
80471   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80472   argp2 = (Dali::AlphaFunction *)jarg2;
80473   if (!argp2) {
80474     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
80475     return ;
80476   }
80477   arg2 = *argp2;
80478   {
80479     try {
80480       (arg1)->SetScrollSnapAlphaFunction(arg2);
80481     } catch (std::out_of_range& e) {
80482       {
80483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80484       };
80485     } catch (std::exception& e) {
80486       {
80487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80488       };
80489     } catch (Dali::DaliException e) {
80490       {
80491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80492       };
80493     } catch (...) {
80494       {
80495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80496       };
80497     }
80498   }
80499
80500 }
80501
80502
80503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickAlphaFunction(void * jarg1) {
80504   void * jresult ;
80505   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80506   Dali::AlphaFunction result;
80507
80508   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80509   {
80510     try {
80511       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickAlphaFunction();
80512     } catch (std::out_of_range& e) {
80513       {
80514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80515       };
80516     } catch (std::exception& e) {
80517       {
80518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80519       };
80520     } catch (Dali::DaliException e) {
80521       {
80522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80523       };
80524     } catch (...) {
80525       {
80526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80527       };
80528     }
80529   }
80530
80531   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
80532   return jresult;
80533 }
80534
80535
80536 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickAlphaFunction(void * jarg1, void * jarg2) {
80537   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80538   Dali::AlphaFunction arg2 ;
80539   Dali::AlphaFunction *argp2 ;
80540
80541   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80542   argp2 = (Dali::AlphaFunction *)jarg2;
80543   if (!argp2) {
80544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
80545     return ;
80546   }
80547   arg2 = *argp2;
80548   {
80549     try {
80550       (arg1)->SetScrollFlickAlphaFunction(arg2);
80551     } catch (std::out_of_range& e) {
80552       {
80553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80554       };
80555     } catch (std::exception& e) {
80556       {
80557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80558       };
80559     } catch (Dali::DaliException e) {
80560       {
80561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80562       };
80563     } catch (...) {
80564       {
80565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80566       };
80567     }
80568   }
80569
80570 }
80571
80572
80573 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapDuration(void * jarg1) {
80574   float jresult ;
80575   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80576   float result;
80577
80578   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80579   {
80580     try {
80581       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapDuration();
80582     } catch (std::out_of_range& e) {
80583       {
80584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80585       };
80586     } catch (std::exception& e) {
80587       {
80588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80589       };
80590     } catch (Dali::DaliException e) {
80591       {
80592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80593       };
80594     } catch (...) {
80595       {
80596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80597       };
80598     }
80599   }
80600
80601   jresult = result;
80602   return jresult;
80603 }
80604
80605
80606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapDuration(void * jarg1, float jarg2) {
80607   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80608   float arg2 ;
80609
80610   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80611   arg2 = (float)jarg2;
80612   {
80613     try {
80614       (arg1)->SetScrollSnapDuration(arg2);
80615     } catch (std::out_of_range& e) {
80616       {
80617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80618       };
80619     } catch (std::exception& e) {
80620       {
80621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80622       };
80623     } catch (Dali::DaliException e) {
80624       {
80625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80626       };
80627     } catch (...) {
80628       {
80629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80630       };
80631     }
80632   }
80633
80634 }
80635
80636
80637 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickDuration(void * jarg1) {
80638   float jresult ;
80639   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80640   float result;
80641
80642   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80643   {
80644     try {
80645       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickDuration();
80646     } catch (std::out_of_range& e) {
80647       {
80648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80649       };
80650     } catch (std::exception& e) {
80651       {
80652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80653       };
80654     } catch (Dali::DaliException e) {
80655       {
80656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80657       };
80658     } catch (...) {
80659       {
80660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80661       };
80662     }
80663   }
80664
80665   jresult = result;
80666   return jresult;
80667 }
80668
80669
80670 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickDuration(void * jarg1, float jarg2) {
80671   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80672   float arg2 ;
80673
80674   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80675   arg2 = (float)jarg2;
80676   {
80677     try {
80678       (arg1)->SetScrollFlickDuration(arg2);
80679     } catch (std::out_of_range& e) {
80680       {
80681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80682       };
80683     } catch (std::exception& e) {
80684       {
80685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80686       };
80687     } catch (Dali::DaliException e) {
80688       {
80689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80690       };
80691     } catch (...) {
80692       {
80693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80694       };
80695     }
80696   }
80697
80698 }
80699
80700
80701 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerX(void * jarg1, void * jarg2) {
80702   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80703   Dali::Toolkit::RulerPtr arg2 ;
80704   Dali::Toolkit::RulerPtr *argp2 ;
80705
80706   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80707   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
80708   if (!argp2) {
80709     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
80710     return ;
80711   }
80712   arg2 = *argp2;
80713   {
80714     try {
80715       (arg1)->SetRulerX(arg2);
80716     } catch (std::out_of_range& e) {
80717       {
80718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80719       };
80720     } catch (std::exception& e) {
80721       {
80722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80723       };
80724     } catch (Dali::DaliException e) {
80725       {
80726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80727       };
80728     } catch (...) {
80729       {
80730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80731       };
80732     }
80733   }
80734
80735 }
80736
80737
80738 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerY(void * jarg1, void * jarg2) {
80739   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80740   Dali::Toolkit::RulerPtr arg2 ;
80741   Dali::Toolkit::RulerPtr *argp2 ;
80742
80743   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80744   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
80745   if (!argp2) {
80746     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
80747     return ;
80748   }
80749   arg2 = *argp2;
80750   {
80751     try {
80752       (arg1)->SetRulerY(arg2);
80753     } catch (std::out_of_range& e) {
80754       {
80755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80756       };
80757     } catch (std::exception& e) {
80758       {
80759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80760       };
80761     } catch (Dali::DaliException e) {
80762       {
80763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80764       };
80765     } catch (...) {
80766       {
80767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80768       };
80769     }
80770   }
80771
80772 }
80773
80774
80775 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSensitive(void * jarg1, unsigned int jarg2) {
80776   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80777   bool arg2 ;
80778
80779   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80780   arg2 = jarg2 ? true : false;
80781   {
80782     try {
80783       (arg1)->SetScrollSensitive(arg2);
80784     } catch (std::out_of_range& e) {
80785       {
80786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80787       };
80788     } catch (std::exception& e) {
80789       {
80790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80791       };
80792     } catch (Dali::DaliException e) {
80793       {
80794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80795       };
80796     } catch (...) {
80797       {
80798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80799       };
80800     }
80801   }
80802
80803 }
80804
80805
80806 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxOvershoot(void * jarg1, float jarg2, float jarg3) {
80807   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80808   float arg2 ;
80809   float arg3 ;
80810
80811   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80812   arg2 = (float)jarg2;
80813   arg3 = (float)jarg3;
80814   {
80815     try {
80816       (arg1)->SetMaxOvershoot(arg2,arg3);
80817     } catch (std::out_of_range& e) {
80818       {
80819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80820       };
80821     } catch (std::exception& e) {
80822       {
80823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80824       };
80825     } catch (Dali::DaliException e) {
80826       {
80827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80828       };
80829     } catch (...) {
80830       {
80831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80832       };
80833     }
80834   }
80835
80836 }
80837
80838
80839 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootAlphaFunction(void * jarg1, void * jarg2) {
80840   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80841   Dali::AlphaFunction arg2 ;
80842   Dali::AlphaFunction *argp2 ;
80843
80844   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80845   argp2 = (Dali::AlphaFunction *)jarg2;
80846   if (!argp2) {
80847     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
80848     return ;
80849   }
80850   arg2 = *argp2;
80851   {
80852     try {
80853       (arg1)->SetSnapOvershootAlphaFunction(arg2);
80854     } catch (std::out_of_range& e) {
80855       {
80856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80857       };
80858     } catch (std::exception& e) {
80859       {
80860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80861       };
80862     } catch (Dali::DaliException e) {
80863       {
80864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80865       };
80866     } catch (...) {
80867       {
80868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80869       };
80870     }
80871   }
80872
80873 }
80874
80875
80876 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootDuration(void * jarg1, float jarg2) {
80877   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80878   float arg2 ;
80879
80880   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80881   arg2 = (float)jarg2;
80882   {
80883     try {
80884       (arg1)->SetSnapOvershootDuration(arg2);
80885     } catch (std::out_of_range& e) {
80886       {
80887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80888       };
80889     } catch (std::exception& e) {
80890       {
80891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80892       };
80893     } catch (Dali::DaliException e) {
80894       {
80895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80896       };
80897     } catch (...) {
80898       {
80899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80900       };
80901     }
80902   }
80903
80904 }
80905
80906
80907 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetActorAutoSnap(void * jarg1, unsigned int jarg2) {
80908   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80909   bool arg2 ;
80910
80911   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80912   arg2 = jarg2 ? true : false;
80913   {
80914     try {
80915       (arg1)->SetActorAutoSnap(arg2);
80916     } catch (std::out_of_range& e) {
80917       {
80918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80919       };
80920     } catch (std::exception& e) {
80921       {
80922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80923       };
80924     } catch (Dali::DaliException e) {
80925       {
80926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80927       };
80928     } catch (...) {
80929       {
80930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80931       };
80932     }
80933   }
80934
80935 }
80936
80937
80938 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWrapMode(void * jarg1, unsigned int jarg2) {
80939   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80940   bool arg2 ;
80941
80942   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80943   arg2 = jarg2 ? true : false;
80944   {
80945     try {
80946       (arg1)->SetWrapMode(arg2);
80947     } catch (std::out_of_range& e) {
80948       {
80949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80950       };
80951     } catch (std::exception& e) {
80952       {
80953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80954       };
80955     } catch (Dali::DaliException e) {
80956       {
80957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80958       };
80959     } catch (...) {
80960       {
80961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80962       };
80963     }
80964   }
80965
80966 }
80967
80968
80969 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollUpdateDistance(void * jarg1) {
80970   int jresult ;
80971   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80972   int result;
80973
80974   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80975   {
80976     try {
80977       result = (int)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollUpdateDistance();
80978     } catch (std::out_of_range& e) {
80979       {
80980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80981       };
80982     } catch (std::exception& e) {
80983       {
80984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80985       };
80986     } catch (Dali::DaliException e) {
80987       {
80988         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80989       };
80990     } catch (...) {
80991       {
80992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80993       };
80994     }
80995   }
80996
80997   jresult = result;
80998   return jresult;
80999 }
81000
81001
81002 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollUpdateDistance(void * jarg1, int jarg2) {
81003   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81004   int arg2 ;
81005
81006   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81007   arg2 = (int)jarg2;
81008   {
81009     try {
81010       (arg1)->SetScrollUpdateDistance(arg2);
81011     } catch (std::out_of_range& e) {
81012       {
81013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81014       };
81015     } catch (std::exception& e) {
81016       {
81017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81018       };
81019     } catch (Dali::DaliException e) {
81020       {
81021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81022       };
81023     } catch (...) {
81024       {
81025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81026       };
81027     }
81028   }
81029
81030 }
81031
81032
81033 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLock(void * jarg1) {
81034   unsigned int jresult ;
81035   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81036   bool result;
81037
81038   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81039   {
81040     try {
81041       result = (bool)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLock();
81042     } catch (std::out_of_range& e) {
81043       {
81044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81045       };
81046     } catch (std::exception& e) {
81047       {
81048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81049       };
81050     } catch (Dali::DaliException e) {
81051       {
81052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81053       };
81054     } catch (...) {
81055       {
81056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81057       };
81058     }
81059   }
81060
81061   jresult = result;
81062   return jresult;
81063 }
81064
81065
81066 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLock(void * jarg1, unsigned int jarg2) {
81067   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81068   bool arg2 ;
81069
81070   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81071   arg2 = jarg2 ? true : false;
81072   {
81073     try {
81074       (arg1)->SetAxisAutoLock(arg2);
81075     } catch (std::out_of_range& e) {
81076       {
81077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81078       };
81079     } catch (std::exception& e) {
81080       {
81081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81082       };
81083     } catch (Dali::DaliException e) {
81084       {
81085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81086       };
81087     } catch (...) {
81088       {
81089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81090       };
81091     }
81092   }
81093
81094 }
81095
81096
81097 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLockGradient(void * jarg1) {
81098   float jresult ;
81099   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81100   float result;
81101
81102   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81103   {
81104     try {
81105       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLockGradient();
81106     } catch (std::out_of_range& e) {
81107       {
81108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81109       };
81110     } catch (std::exception& e) {
81111       {
81112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81113       };
81114     } catch (Dali::DaliException e) {
81115       {
81116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81117       };
81118     } catch (...) {
81119       {
81120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81121       };
81122     }
81123   }
81124
81125   jresult = result;
81126   return jresult;
81127 }
81128
81129
81130 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLockGradient(void * jarg1, float jarg2) {
81131   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81132   float arg2 ;
81133
81134   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81135   arg2 = (float)jarg2;
81136   {
81137     try {
81138       (arg1)->SetAxisAutoLockGradient(arg2);
81139     } catch (std::out_of_range& e) {
81140       {
81141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81142       };
81143     } catch (std::exception& e) {
81144       {
81145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81146       };
81147     } catch (Dali::DaliException e) {
81148       {
81149         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81150       };
81151     } catch (...) {
81152       {
81153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81154       };
81155     }
81156   }
81157
81158 }
81159
81160
81161 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFrictionCoefficient(void * jarg1) {
81162   float jresult ;
81163   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81164   float result;
81165
81166   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81167   {
81168     try {
81169       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFrictionCoefficient();
81170     } catch (std::out_of_range& e) {
81171       {
81172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81173       };
81174     } catch (std::exception& e) {
81175       {
81176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81177       };
81178     } catch (Dali::DaliException e) {
81179       {
81180         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81181       };
81182     } catch (...) {
81183       {
81184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81185       };
81186     }
81187   }
81188
81189   jresult = result;
81190   return jresult;
81191 }
81192
81193
81194 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFrictionCoefficient(void * jarg1, float jarg2) {
81195   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81196   float arg2 ;
81197
81198   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81199   arg2 = (float)jarg2;
81200   {
81201     try {
81202       (arg1)->SetFrictionCoefficient(arg2);
81203     } catch (std::out_of_range& e) {
81204       {
81205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81206       };
81207     } catch (std::exception& e) {
81208       {
81209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81210       };
81211     } catch (Dali::DaliException e) {
81212       {
81213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81214       };
81215     } catch (...) {
81216       {
81217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81218       };
81219     }
81220   }
81221
81222 }
81223
81224
81225 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFlickSpeedCoefficient(void * jarg1) {
81226   float jresult ;
81227   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81228   float result;
81229
81230   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81231   {
81232     try {
81233       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFlickSpeedCoefficient();
81234     } catch (std::out_of_range& e) {
81235       {
81236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81237       };
81238     } catch (std::exception& e) {
81239       {
81240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81241       };
81242     } catch (Dali::DaliException e) {
81243       {
81244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81245       };
81246     } catch (...) {
81247       {
81248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81249       };
81250     }
81251   }
81252
81253   jresult = result;
81254   return jresult;
81255 }
81256
81257
81258 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFlickSpeedCoefficient(void * jarg1, float jarg2) {
81259   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81260   float arg2 ;
81261
81262   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81263   arg2 = (float)jarg2;
81264   {
81265     try {
81266       (arg1)->SetFlickSpeedCoefficient(arg2);
81267     } catch (std::out_of_range& e) {
81268       {
81269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81270       };
81271     } catch (std::exception& e) {
81272       {
81273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81274       };
81275     } catch (Dali::DaliException e) {
81276       {
81277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81278       };
81279     } catch (...) {
81280       {
81281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81282       };
81283     }
81284   }
81285
81286 }
81287
81288
81289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumDistanceForFlick(void * jarg1) {
81290   void * jresult ;
81291   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81292   Dali::Vector2 result;
81293
81294   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81295   {
81296     try {
81297       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumDistanceForFlick();
81298     } catch (std::out_of_range& e) {
81299       {
81300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81301       };
81302     } catch (std::exception& e) {
81303       {
81304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81305       };
81306     } catch (Dali::DaliException e) {
81307       {
81308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81309       };
81310     } catch (...) {
81311       {
81312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81313       };
81314     }
81315   }
81316
81317   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
81318   return jresult;
81319 }
81320
81321
81322 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumDistanceForFlick(void * jarg1, void * jarg2) {
81323   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81324   Dali::Vector2 *arg2 = 0 ;
81325
81326   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81327   arg2 = (Dali::Vector2 *)jarg2;
81328   if (!arg2) {
81329     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81330     return ;
81331   }
81332   {
81333     try {
81334       (arg1)->SetMinimumDistanceForFlick((Dali::Vector2 const &)*arg2);
81335     } catch (std::out_of_range& e) {
81336       {
81337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81338       };
81339     } catch (std::exception& e) {
81340       {
81341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81342       };
81343     } catch (Dali::DaliException e) {
81344       {
81345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81346       };
81347     } catch (...) {
81348       {
81349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81350       };
81351     }
81352   }
81353
81354 }
81355
81356
81357 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumSpeedForFlick(void * jarg1) {
81358   float jresult ;
81359   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81360   float result;
81361
81362   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81363   {
81364     try {
81365       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumSpeedForFlick();
81366     } catch (std::out_of_range& e) {
81367       {
81368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81369       };
81370     } catch (std::exception& e) {
81371       {
81372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81373       };
81374     } catch (Dali::DaliException e) {
81375       {
81376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81377       };
81378     } catch (...) {
81379       {
81380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81381       };
81382     }
81383   }
81384
81385   jresult = result;
81386   return jresult;
81387 }
81388
81389
81390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumSpeedForFlick(void * jarg1, float jarg2) {
81391   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81392   float arg2 ;
81393
81394   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81395   arg2 = (float)jarg2;
81396   {
81397     try {
81398       (arg1)->SetMinimumSpeedForFlick(arg2);
81399     } catch (std::out_of_range& e) {
81400       {
81401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81402       };
81403     } catch (std::exception& e) {
81404       {
81405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81406       };
81407     } catch (Dali::DaliException e) {
81408       {
81409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81410       };
81411     } catch (...) {
81412       {
81413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81414       };
81415     }
81416   }
81417
81418 }
81419
81420
81421 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMaxFlickSpeed(void * jarg1) {
81422   float jresult ;
81423   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81424   float result;
81425
81426   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81427   {
81428     try {
81429       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMaxFlickSpeed();
81430     } catch (std::out_of_range& e) {
81431       {
81432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81433       };
81434     } catch (std::exception& e) {
81435       {
81436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81437       };
81438     } catch (Dali::DaliException e) {
81439       {
81440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81441       };
81442     } catch (...) {
81443       {
81444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81445       };
81446     }
81447   }
81448
81449   jresult = result;
81450   return jresult;
81451 }
81452
81453
81454 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxFlickSpeed(void * jarg1, float jarg2) {
81455   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81456   float arg2 ;
81457
81458   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81459   arg2 = (float)jarg2;
81460   {
81461     try {
81462       (arg1)->SetMaxFlickSpeed(arg2);
81463     } catch (std::out_of_range& e) {
81464       {
81465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81466       };
81467     } catch (std::exception& e) {
81468       {
81469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81470       };
81471     } catch (Dali::DaliException e) {
81472       {
81473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81474       };
81475     } catch (...) {
81476       {
81477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81478       };
81479     }
81480   }
81481
81482 }
81483
81484
81485 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetWheelScrollDistanceStep(void * jarg1) {
81486   void * jresult ;
81487   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81488   Dali::Vector2 result;
81489
81490   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81491   {
81492     try {
81493       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetWheelScrollDistanceStep();
81494     } catch (std::out_of_range& e) {
81495       {
81496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81497       };
81498     } catch (std::exception& e) {
81499       {
81500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81501       };
81502     } catch (Dali::DaliException e) {
81503       {
81504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81505       };
81506     } catch (...) {
81507       {
81508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81509       };
81510     }
81511   }
81512
81513   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
81514   return jresult;
81515 }
81516
81517
81518 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWheelScrollDistanceStep(void * jarg1, void * jarg2) {
81519   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81520   Dali::Vector2 arg2 ;
81521   Dali::Vector2 *argp2 ;
81522
81523   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81524   argp2 = (Dali::Vector2 *)jarg2;
81525   if (!argp2) {
81526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
81527     return ;
81528   }
81529   arg2 = *argp2;
81530   {
81531     try {
81532       (arg1)->SetWheelScrollDistanceStep(arg2);
81533     } catch (std::out_of_range& e) {
81534       {
81535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81536       };
81537     } catch (std::exception& e) {
81538       {
81539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81540       };
81541     } catch (Dali::DaliException e) {
81542       {
81543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81544       };
81545     } catch (...) {
81546       {
81547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81548       };
81549     }
81550   }
81551
81552 }
81553
81554
81555 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentScrollPosition(void * jarg1) {
81556   void * jresult ;
81557   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81558   Dali::Vector2 result;
81559
81560   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81561   {
81562     try {
81563       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentScrollPosition();
81564     } catch (std::out_of_range& e) {
81565       {
81566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81567       };
81568     } catch (std::exception& e) {
81569       {
81570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81571       };
81572     } catch (Dali::DaliException e) {
81573       {
81574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81575       };
81576     } catch (...) {
81577       {
81578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81579       };
81580     }
81581   }
81582
81583   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
81584   return jresult;
81585 }
81586
81587
81588 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentPage(void * jarg1) {
81589   unsigned int jresult ;
81590   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81591   unsigned int result;
81592
81593   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81594   {
81595     try {
81596       result = (unsigned int)((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentPage();
81597     } catch (std::out_of_range& e) {
81598       {
81599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81600       };
81601     } catch (std::exception& e) {
81602       {
81603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81604       };
81605     } catch (Dali::DaliException e) {
81606       {
81607         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81608       };
81609     } catch (...) {
81610       {
81611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81612       };
81613     }
81614   }
81615
81616   jresult = result;
81617   return jresult;
81618 }
81619
81620
81621 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_0(void * jarg1, void * jarg2) {
81622   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81623   Dali::Vector2 *arg2 = 0 ;
81624
81625   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81626   arg2 = (Dali::Vector2 *)jarg2;
81627   if (!arg2) {
81628     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81629     return ;
81630   }
81631   {
81632     try {
81633       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2);
81634     } catch (std::out_of_range& e) {
81635       {
81636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81637       };
81638     } catch (std::exception& e) {
81639       {
81640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81641       };
81642     } catch (Dali::DaliException e) {
81643       {
81644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81645       };
81646     } catch (...) {
81647       {
81648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81649       };
81650     }
81651   }
81652
81653 }
81654
81655
81656 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
81657   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81658   Dali::Vector2 *arg2 = 0 ;
81659   float arg3 ;
81660
81661   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81662   arg2 = (Dali::Vector2 *)jarg2;
81663   if (!arg2) {
81664     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81665     return ;
81666   }
81667   arg3 = (float)jarg3;
81668   {
81669     try {
81670       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3);
81671     } catch (std::out_of_range& e) {
81672       {
81673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81674       };
81675     } catch (std::exception& e) {
81676       {
81677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81678       };
81679     } catch (Dali::DaliException e) {
81680       {
81681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81682       };
81683     } catch (...) {
81684       {
81685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81686       };
81687     }
81688   }
81689
81690 }
81691
81692
81693 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_2(void * jarg1, void * jarg2, float jarg3, void * jarg4) {
81694   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81695   Dali::Vector2 *arg2 = 0 ;
81696   float arg3 ;
81697   Dali::AlphaFunction arg4 ;
81698   Dali::AlphaFunction *argp4 ;
81699
81700   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81701   arg2 = (Dali::Vector2 *)jarg2;
81702   if (!arg2) {
81703     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81704     return ;
81705   }
81706   arg3 = (float)jarg3;
81707   argp4 = (Dali::AlphaFunction *)jarg4;
81708   if (!argp4) {
81709     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
81710     return ;
81711   }
81712   arg4 = *argp4;
81713   {
81714     try {
81715       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4);
81716     } catch (std::out_of_range& e) {
81717       {
81718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81719       };
81720     } catch (std::exception& e) {
81721       {
81722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81723       };
81724     } catch (Dali::DaliException e) {
81725       {
81726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81727       };
81728     } catch (...) {
81729       {
81730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81731       };
81732     }
81733   }
81734
81735 }
81736
81737
81738 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_3(void * jarg1, void * jarg2, float jarg3, int jarg4, int jarg5) {
81739   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81740   Dali::Vector2 *arg2 = 0 ;
81741   float arg3 ;
81742   Dali::Toolkit::DirectionBias arg4 ;
81743   Dali::Toolkit::DirectionBias arg5 ;
81744
81745   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81746   arg2 = (Dali::Vector2 *)jarg2;
81747   if (!arg2) {
81748     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81749     return ;
81750   }
81751   arg3 = (float)jarg3;
81752   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
81753   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
81754   {
81755     try {
81756       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5);
81757     } catch (std::out_of_range& e) {
81758       {
81759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81760       };
81761     } catch (std::exception& e) {
81762       {
81763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81764       };
81765     } catch (Dali::DaliException e) {
81766       {
81767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81768       };
81769     } catch (...) {
81770       {
81771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81772       };
81773     }
81774   }
81775
81776 }
81777
81778
81779 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_4(void * jarg1, void * jarg2, float jarg3, void * jarg4, int jarg5, int jarg6) {
81780   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81781   Dali::Vector2 *arg2 = 0 ;
81782   float arg3 ;
81783   Dali::AlphaFunction arg4 ;
81784   Dali::Toolkit::DirectionBias arg5 ;
81785   Dali::Toolkit::DirectionBias arg6 ;
81786   Dali::AlphaFunction *argp4 ;
81787
81788   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81789   arg2 = (Dali::Vector2 *)jarg2;
81790   if (!arg2) {
81791     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81792     return ;
81793   }
81794   arg3 = (float)jarg3;
81795   argp4 = (Dali::AlphaFunction *)jarg4;
81796   if (!argp4) {
81797     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
81798     return ;
81799   }
81800   arg4 = *argp4;
81801   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
81802   arg6 = (Dali::Toolkit::DirectionBias)jarg6;
81803   {
81804     try {
81805       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5,arg6);
81806     } catch (std::out_of_range& e) {
81807       {
81808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81809       };
81810     } catch (std::exception& e) {
81811       {
81812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81813       };
81814     } catch (Dali::DaliException e) {
81815       {
81816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81817       };
81818     } catch (...) {
81819       {
81820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81821       };
81822     }
81823   }
81824
81825 }
81826
81827
81828 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_5(void * jarg1, unsigned int jarg2) {
81829   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81830   unsigned int arg2 ;
81831
81832   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81833   arg2 = (unsigned int)jarg2;
81834   {
81835     try {
81836       (arg1)->ScrollTo(arg2);
81837     } catch (std::out_of_range& e) {
81838       {
81839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81840       };
81841     } catch (std::exception& e) {
81842       {
81843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81844       };
81845     } catch (Dali::DaliException e) {
81846       {
81847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81848       };
81849     } catch (...) {
81850       {
81851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81852       };
81853     }
81854   }
81855
81856 }
81857
81858
81859 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_6(void * jarg1, unsigned int jarg2, float jarg3) {
81860   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81861   unsigned int arg2 ;
81862   float arg3 ;
81863
81864   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81865   arg2 = (unsigned int)jarg2;
81866   arg3 = (float)jarg3;
81867   {
81868     try {
81869       (arg1)->ScrollTo(arg2,arg3);
81870     } catch (std::out_of_range& e) {
81871       {
81872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81873       };
81874     } catch (std::exception& e) {
81875       {
81876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81877       };
81878     } catch (Dali::DaliException e) {
81879       {
81880         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81881       };
81882     } catch (...) {
81883       {
81884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81885       };
81886     }
81887   }
81888
81889 }
81890
81891
81892 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_7(void * jarg1, unsigned int jarg2, float jarg3, int jarg4) {
81893   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81894   unsigned int arg2 ;
81895   float arg3 ;
81896   Dali::Toolkit::DirectionBias arg4 ;
81897
81898   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81899   arg2 = (unsigned int)jarg2;
81900   arg3 = (float)jarg3;
81901   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
81902   {
81903     try {
81904       (arg1)->ScrollTo(arg2,arg3,arg4);
81905     } catch (std::out_of_range& e) {
81906       {
81907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81908       };
81909     } catch (std::exception& e) {
81910       {
81911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81912       };
81913     } catch (Dali::DaliException e) {
81914       {
81915         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81916       };
81917     } catch (...) {
81918       {
81919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81920       };
81921     }
81922   }
81923
81924 }
81925
81926
81927 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_8(void * jarg1, void * jarg2) {
81928   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81929   Dali::Actor *arg2 = 0 ;
81930
81931   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81932   arg2 = (Dali::Actor *)jarg2;
81933   if (!arg2) {
81934     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
81935     return ;
81936   }
81937   {
81938     try {
81939       (arg1)->ScrollTo(*arg2);
81940     } catch (std::out_of_range& e) {
81941       {
81942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81943       };
81944     } catch (std::exception& e) {
81945       {
81946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81947       };
81948     } catch (Dali::DaliException e) {
81949       {
81950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81951       };
81952     } catch (...) {
81953       {
81954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81955       };
81956     }
81957   }
81958
81959 }
81960
81961
81962 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_9(void * jarg1, void * jarg2, float jarg3) {
81963   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81964   Dali::Actor *arg2 = 0 ;
81965   float arg3 ;
81966
81967   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81968   arg2 = (Dali::Actor *)jarg2;
81969   if (!arg2) {
81970     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
81971     return ;
81972   }
81973   arg3 = (float)jarg3;
81974   {
81975     try {
81976       (arg1)->ScrollTo(*arg2,arg3);
81977     } catch (std::out_of_range& e) {
81978       {
81979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81980       };
81981     } catch (std::exception& e) {
81982       {
81983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81984       };
81985     } catch (Dali::DaliException e) {
81986       {
81987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81988       };
81989     } catch (...) {
81990       {
81991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81992       };
81993     }
81994   }
81995
81996 }
81997
81998
81999 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_ScrollToSnapPoint(void * jarg1) {
82000   unsigned int jresult ;
82001   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82002   bool result;
82003
82004   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82005   {
82006     try {
82007       result = (bool)(arg1)->ScrollToSnapPoint();
82008     } catch (std::out_of_range& e) {
82009       {
82010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82011       };
82012     } catch (std::exception& e) {
82013       {
82014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82015       };
82016     } catch (Dali::DaliException e) {
82017       {
82018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82019       };
82020     } catch (...) {
82021       {
82022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82023       };
82024     }
82025   }
82026
82027   jresult = result;
82028   return jresult;
82029 }
82030
82031
82032 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyConstraintToChildren(void * jarg1, void * jarg2) {
82033   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82034   Dali::Constraint arg2 ;
82035   Dali::Constraint *argp2 ;
82036
82037   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82038   argp2 = (Dali::Constraint *)jarg2;
82039   if (!argp2) {
82040     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Constraint", 0);
82041     return ;
82042   }
82043   arg2 = *argp2;
82044   {
82045     try {
82046       (arg1)->ApplyConstraintToChildren(arg2);
82047     } catch (std::out_of_range& e) {
82048       {
82049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82050       };
82051     } catch (std::exception& e) {
82052       {
82053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82054       };
82055     } catch (Dali::DaliException e) {
82056       {
82057         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82058       };
82059     } catch (...) {
82060       {
82061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82062       };
82063     }
82064   }
82065
82066 }
82067
82068
82069 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveConstraintsFromChildren(void * jarg1) {
82070   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82071
82072   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82073   {
82074     try {
82075       (arg1)->RemoveConstraintsFromChildren();
82076     } catch (std::out_of_range& e) {
82077       {
82078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82079       };
82080     } catch (std::exception& e) {
82081       {
82082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82083       };
82084     } catch (Dali::DaliException e) {
82085       {
82086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82087       };
82088     } catch (...) {
82089       {
82090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82091       };
82092     }
82093   }
82094
82095 }
82096
82097
82098 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyEffect(void * jarg1, void * jarg2) {
82099   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82100   Dali::Toolkit::ScrollViewEffect arg2 ;
82101   Dali::Toolkit::ScrollViewEffect *argp2 ;
82102
82103   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82104   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
82105   if (!argp2) {
82106     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
82107     return ;
82108   }
82109   arg2 = *argp2;
82110   {
82111     try {
82112       (arg1)->ApplyEffect(arg2);
82113     } catch (std::out_of_range& e) {
82114       {
82115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82116       };
82117     } catch (std::exception& e) {
82118       {
82119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82120       };
82121     } catch (Dali::DaliException e) {
82122       {
82123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82124       };
82125     } catch (...) {
82126       {
82127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82128       };
82129     }
82130   }
82131
82132 }
82133
82134
82135 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveEffect(void * jarg1, void * jarg2) {
82136   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82137   Dali::Toolkit::ScrollViewEffect arg2 ;
82138   Dali::Toolkit::ScrollViewEffect *argp2 ;
82139
82140   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82141   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
82142   if (!argp2) {
82143     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
82144     return ;
82145   }
82146   arg2 = *argp2;
82147   {
82148     try {
82149       (arg1)->RemoveEffect(arg2);
82150     } catch (std::out_of_range& e) {
82151       {
82152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82153       };
82154     } catch (std::exception& e) {
82155       {
82156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82157       };
82158     } catch (Dali::DaliException e) {
82159       {
82160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82161       };
82162     } catch (...) {
82163       {
82164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82165       };
82166     }
82167   }
82168
82169 }
82170
82171
82172 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveAllEffects(void * jarg1) {
82173   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82174
82175   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82176   {
82177     try {
82178       (arg1)->RemoveAllEffects();
82179     } catch (std::out_of_range& e) {
82180       {
82181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82182       };
82183     } catch (std::exception& e) {
82184       {
82185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82186       };
82187     } catch (Dali::DaliException e) {
82188       {
82189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82190       };
82191     } catch (...) {
82192       {
82193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82194       };
82195     }
82196   }
82197
82198 }
82199
82200
82201 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_BindActor(void * jarg1, void * jarg2) {
82202   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82203   Dali::Actor arg2 ;
82204   Dali::Actor *argp2 ;
82205
82206   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82207   argp2 = (Dali::Actor *)jarg2;
82208   if (!argp2) {
82209     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82210     return ;
82211   }
82212   arg2 = *argp2;
82213   {
82214     try {
82215       (arg1)->BindActor(arg2);
82216     } catch (std::out_of_range& e) {
82217       {
82218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82219       };
82220     } catch (std::exception& e) {
82221       {
82222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82223       };
82224     } catch (Dali::DaliException e) {
82225       {
82226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82227       };
82228     } catch (...) {
82229       {
82230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82231       };
82232     }
82233   }
82234
82235 }
82236
82237
82238 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_UnbindActor(void * jarg1, void * jarg2) {
82239   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82240   Dali::Actor arg2 ;
82241   Dali::Actor *argp2 ;
82242
82243   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82244   argp2 = (Dali::Actor *)jarg2;
82245   if (!argp2) {
82246     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82247     return ;
82248   }
82249   arg2 = *argp2;
82250   {
82251     try {
82252       (arg1)->UnbindActor(arg2);
82253     } catch (std::out_of_range& e) {
82254       {
82255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82256       };
82257     } catch (std::exception& e) {
82258       {
82259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82260       };
82261     } catch (Dali::DaliException e) {
82262       {
82263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82264       };
82265     } catch (...) {
82266       {
82267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82268       };
82269     }
82270   }
82271
82272 }
82273
82274
82275 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
82276   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82277   Dali::Radian arg2 ;
82278   Dali::Radian arg3 ;
82279   Dali::Radian *argp2 ;
82280   Dali::Radian *argp3 ;
82281
82282   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82283   argp2 = (Dali::Radian *)jarg2;
82284   if (!argp2) {
82285     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
82286     return ;
82287   }
82288   arg2 = *argp2;
82289   argp3 = (Dali::Radian *)jarg3;
82290   if (!argp3) {
82291     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
82292     return ;
82293   }
82294   arg3 = *argp3;
82295   {
82296     try {
82297       (arg1)->SetScrollingDirection(arg2,arg3);
82298     } catch (std::out_of_range& e) {
82299       {
82300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82301       };
82302     } catch (std::exception& e) {
82303       {
82304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82305       };
82306     } catch (Dali::DaliException e) {
82307       {
82308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82309       };
82310     } catch (...) {
82311       {
82312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82313       };
82314     }
82315   }
82316
82317 }
82318
82319
82320 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_1(void * jarg1, void * jarg2) {
82321   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82322   Dali::Radian arg2 ;
82323   Dali::Radian *argp2 ;
82324
82325   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82326   argp2 = (Dali::Radian *)jarg2;
82327   if (!argp2) {
82328     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
82329     return ;
82330   }
82331   arg2 = *argp2;
82332   {
82333     try {
82334       (arg1)->SetScrollingDirection(arg2);
82335     } catch (std::out_of_range& e) {
82336       {
82337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82338       };
82339     } catch (std::exception& e) {
82340       {
82341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82342       };
82343     } catch (Dali::DaliException e) {
82344       {
82345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82346       };
82347     } catch (...) {
82348       {
82349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82350       };
82351     }
82352   }
82353
82354 }
82355
82356
82357 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveScrollingDirection(void * jarg1, void * jarg2) {
82358   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82359   Dali::Radian arg2 ;
82360   Dali::Radian *argp2 ;
82361
82362   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82363   argp2 = (Dali::Radian *)jarg2;
82364   if (!argp2) {
82365     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
82366     return ;
82367   }
82368   arg2 = *argp2;
82369   {
82370     try {
82371       (arg1)->RemoveScrollingDirection(arg2);
82372     } catch (std::out_of_range& e) {
82373       {
82374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82375       };
82376     } catch (std::exception& e) {
82377       {
82378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82379       };
82380     } catch (Dali::DaliException e) {
82381       {
82382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82383       };
82384     } catch (...) {
82385       {
82386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82387       };
82388     }
82389   }
82390
82391 }
82392
82393
82394 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapStartedSignal(void * jarg1) {
82395   void * jresult ;
82396   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82397   Dali::Toolkit::ScrollView::SnapStartedSignalType *result = 0 ;
82398
82399   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82400   {
82401     try {
82402       result = (Dali::Toolkit::ScrollView::SnapStartedSignalType *) &(arg1)->SnapStartedSignal();
82403     } catch (std::out_of_range& e) {
82404       {
82405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82406       };
82407     } catch (std::exception& e) {
82408       {
82409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82410       };
82411     } catch (Dali::DaliException e) {
82412       {
82413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82414       };
82415     } catch (...) {
82416       {
82417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82418       };
82419     }
82420   }
82421
82422   jresult = (void *)result;
82423   return jresult;
82424 }
82425
82426
82427 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_ROWS_get() {
82428   int jresult ;
82429   int result;
82430
82431   result = (int)Dali::Toolkit::TableView::Property::ROWS;
82432   jresult = (int)result;
82433   return jresult;
82434 }
82435
82436
82437 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_COLUMNS_get() {
82438   int jresult ;
82439   int result;
82440
82441   result = (int)Dali::Toolkit::TableView::Property::COLUMNS;
82442   jresult = (int)result;
82443   return jresult;
82444 }
82445
82446
82447 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_CELL_PADDING_get() {
82448   int jresult ;
82449   int result;
82450
82451   result = (int)Dali::Toolkit::TableView::Property::CELL_PADDING;
82452   jresult = (int)result;
82453   return jresult;
82454 }
82455
82456
82457 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_ROWS_get() {
82458   int jresult ;
82459   int result;
82460
82461   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_ROWS;
82462   jresult = (int)result;
82463   return jresult;
82464 }
82465
82466
82467 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_COLUMNS_get() {
82468   int jresult ;
82469   int result;
82470
82471   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_COLUMNS;
82472   jresult = (int)result;
82473   return jresult;
82474 }
82475
82476
82477 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_Property() {
82478   void * jresult ;
82479   Dali::Toolkit::TableView::Property *result = 0 ;
82480
82481   {
82482     try {
82483       result = (Dali::Toolkit::TableView::Property *)new Dali::Toolkit::TableView::Property();
82484     } catch (std::out_of_range& e) {
82485       {
82486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82487       };
82488     } catch (std::exception& e) {
82489       {
82490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82491       };
82492     } catch (Dali::DaliException e) {
82493       {
82494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82495       };
82496     } catch (...) {
82497       {
82498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82499       };
82500     }
82501   }
82502
82503   jresult = (void *)result;
82504   return jresult;
82505 }
82506
82507
82508 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_Property(void * jarg1) {
82509   Dali::Toolkit::TableView::Property *arg1 = (Dali::Toolkit::TableView::Property *) 0 ;
82510
82511   arg1 = (Dali::Toolkit::TableView::Property *)jarg1;
82512   {
82513     try {
82514       delete arg1;
82515     } catch (std::out_of_range& e) {
82516       {
82517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82518       };
82519     } catch (std::exception& e) {
82520       {
82521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82522       };
82523     } catch (Dali::DaliException e) {
82524       {
82525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82526       };
82527     } catch (...) {
82528       {
82529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82530       };
82531     }
82532   }
82533
82534 }
82535
82536
82537 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_INDEX_get() {
82538   int jresult ;
82539   int result;
82540
82541   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_INDEX;
82542   jresult = (int)result;
82543   return jresult;
82544 }
82545
82546
82547 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_ROW_SPAN_get() {
82548   int jresult ;
82549   int result;
82550
82551   result = (int)Dali::Toolkit::TableView::ChildProperty::ROW_SPAN;
82552   jresult = (int)result;
82553   return jresult;
82554 }
82555
82556
82557 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_COLUMN_SPAN_get() {
82558   int jresult ;
82559   int result;
82560
82561   result = (int)Dali::Toolkit::TableView::ChildProperty::COLUMN_SPAN;
82562   jresult = (int)result;
82563   return jresult;
82564 }
82565
82566
82567 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_HORIZONTAL_ALIGNMENT_get() {
82568   int jresult ;
82569   int result;
82570
82571   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_HORIZONTAL_ALIGNMENT;
82572   jresult = (int)result;
82573   return jresult;
82574 }
82575
82576
82577 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_VERTICAL_ALIGNMENT_get() {
82578   int jresult ;
82579   int result;
82580
82581   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_VERTICAL_ALIGNMENT;
82582   jresult = (int)result;
82583   return jresult;
82584 }
82585
82586
82587 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_ChildProperty() {
82588   void * jresult ;
82589   Dali::Toolkit::TableView::ChildProperty *result = 0 ;
82590
82591   {
82592     try {
82593       result = (Dali::Toolkit::TableView::ChildProperty *)new Dali::Toolkit::TableView::ChildProperty();
82594     } catch (std::out_of_range& e) {
82595       {
82596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82597       };
82598     } catch (std::exception& e) {
82599       {
82600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82601       };
82602     } catch (Dali::DaliException e) {
82603       {
82604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82605       };
82606     } catch (...) {
82607       {
82608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82609       };
82610     }
82611   }
82612
82613   jresult = (void *)result;
82614   return jresult;
82615 }
82616
82617
82618 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_ChildProperty(void * jarg1) {
82619   Dali::Toolkit::TableView::ChildProperty *arg1 = (Dali::Toolkit::TableView::ChildProperty *) 0 ;
82620
82621   arg1 = (Dali::Toolkit::TableView::ChildProperty *)jarg1;
82622   {
82623     try {
82624       delete arg1;
82625     } catch (std::out_of_range& e) {
82626       {
82627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82628       };
82629     } catch (std::exception& e) {
82630       {
82631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82632       };
82633     } catch (Dali::DaliException e) {
82634       {
82635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82636       };
82637     } catch (...) {
82638       {
82639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82640       };
82641     }
82642   }
82643
82644 }
82645
82646
82647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_0(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) {
82648   void * jresult ;
82649   unsigned int arg1 ;
82650   unsigned int arg2 ;
82651   unsigned int arg3 ;
82652   unsigned int arg4 ;
82653   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82654
82655   arg1 = (unsigned int)jarg1;
82656   arg2 = (unsigned int)jarg2;
82657   arg3 = (unsigned int)jarg3;
82658   arg4 = (unsigned int)jarg4;
82659   {
82660     try {
82661       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3,arg4);
82662     } catch (std::out_of_range& e) {
82663       {
82664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82665       };
82666     } catch (std::exception& e) {
82667       {
82668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82669       };
82670     } catch (Dali::DaliException e) {
82671       {
82672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82673       };
82674     } catch (...) {
82675       {
82676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82677       };
82678     }
82679   }
82680
82681   jresult = (void *)result;
82682   return jresult;
82683 }
82684
82685
82686 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_1(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
82687   void * jresult ;
82688   unsigned int arg1 ;
82689   unsigned int arg2 ;
82690   unsigned int arg3 ;
82691   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82692
82693   arg1 = (unsigned int)jarg1;
82694   arg2 = (unsigned int)jarg2;
82695   arg3 = (unsigned int)jarg3;
82696   {
82697     try {
82698       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3);
82699     } catch (std::out_of_range& e) {
82700       {
82701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82702       };
82703     } catch (std::exception& e) {
82704       {
82705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82706       };
82707     } catch (Dali::DaliException e) {
82708       {
82709         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82710       };
82711     } catch (...) {
82712       {
82713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82714       };
82715     }
82716   }
82717
82718   jresult = (void *)result;
82719   return jresult;
82720 }
82721
82722
82723 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
82724   void * jresult ;
82725   unsigned int arg1 ;
82726   unsigned int arg2 ;
82727   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82728
82729   arg1 = (unsigned int)jarg1;
82730   arg2 = (unsigned int)jarg2;
82731   {
82732     try {
82733       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2);
82734     } catch (std::out_of_range& e) {
82735       {
82736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82737       };
82738     } catch (std::exception& e) {
82739       {
82740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82741       };
82742     } catch (Dali::DaliException e) {
82743       {
82744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82745       };
82746     } catch (...) {
82747       {
82748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82749       };
82750     }
82751   }
82752
82753   jresult = (void *)result;
82754   return jresult;
82755 }
82756
82757
82758 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_3(unsigned int jarg1) {
82759   void * jresult ;
82760   unsigned int arg1 ;
82761   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82762
82763   arg1 = (unsigned int)jarg1;
82764   {
82765     try {
82766       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1);
82767     } catch (std::out_of_range& e) {
82768       {
82769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82770       };
82771     } catch (std::exception& e) {
82772       {
82773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82774       };
82775     } catch (Dali::DaliException e) {
82776       {
82777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82778       };
82779     } catch (...) {
82780       {
82781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82782       };
82783     }
82784   }
82785
82786   jresult = (void *)result;
82787   return jresult;
82788 }
82789
82790
82791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_4() {
82792   void * jresult ;
82793   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82794
82795   {
82796     try {
82797       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition();
82798     } catch (std::out_of_range& e) {
82799       {
82800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82801       };
82802     } catch (std::exception& e) {
82803       {
82804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82805       };
82806     } catch (Dali::DaliException e) {
82807       {
82808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82809       };
82810     } catch (...) {
82811       {
82812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82813       };
82814     }
82815   }
82816
82817   jresult = (void *)result;
82818   return jresult;
82819 }
82820
82821
82822 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_set(void * jarg1, unsigned int jarg2) {
82823   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82824   unsigned int arg2 ;
82825
82826   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82827   arg2 = (unsigned int)jarg2;
82828   if (arg1) (arg1)->rowIndex = arg2;
82829 }
82830
82831
82832 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_get(void * jarg1) {
82833   unsigned int jresult ;
82834   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82835   unsigned int result;
82836
82837   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82838   result = (unsigned int) ((arg1)->rowIndex);
82839   jresult = result;
82840   return jresult;
82841 }
82842
82843
82844 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_set(void * jarg1, unsigned int jarg2) {
82845   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82846   unsigned int arg2 ;
82847
82848   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82849   arg2 = (unsigned int)jarg2;
82850   if (arg1) (arg1)->columnIndex = arg2;
82851 }
82852
82853
82854 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_get(void * jarg1) {
82855   unsigned int jresult ;
82856   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82857   unsigned int result;
82858
82859   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82860   result = (unsigned int) ((arg1)->columnIndex);
82861   jresult = result;
82862   return jresult;
82863 }
82864
82865
82866 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_set(void * jarg1, unsigned int jarg2) {
82867   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82868   unsigned int arg2 ;
82869
82870   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82871   arg2 = (unsigned int)jarg2;
82872   if (arg1) (arg1)->rowSpan = arg2;
82873 }
82874
82875
82876 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_get(void * jarg1) {
82877   unsigned int jresult ;
82878   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82879   unsigned int result;
82880
82881   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82882   result = (unsigned int) ((arg1)->rowSpan);
82883   jresult = result;
82884   return jresult;
82885 }
82886
82887
82888 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_set(void * jarg1, unsigned int jarg2) {
82889   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82890   unsigned int arg2 ;
82891
82892   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82893   arg2 = (unsigned int)jarg2;
82894   if (arg1) (arg1)->columnSpan = arg2;
82895 }
82896
82897
82898 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_get(void * jarg1) {
82899   unsigned int jresult ;
82900   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82901   unsigned int result;
82902
82903   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82904   result = (unsigned int) ((arg1)->columnSpan);
82905   jresult = result;
82906   return jresult;
82907 }
82908
82909
82910 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_CellPosition(void * jarg1) {
82911   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82912
82913   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82914   {
82915     try {
82916       delete arg1;
82917     } catch (std::out_of_range& e) {
82918       {
82919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82920       };
82921     } catch (std::exception& e) {
82922       {
82923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82924       };
82925     } catch (Dali::DaliException e) {
82926       {
82927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82928       };
82929     } catch (...) {
82930       {
82931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82932       };
82933     }
82934   }
82935
82936 }
82937
82938
82939 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_0() {
82940   void * jresult ;
82941   Dali::Toolkit::TableView *result = 0 ;
82942
82943   {
82944     try {
82945       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView();
82946     } catch (std::out_of_range& e) {
82947       {
82948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82949       };
82950     } catch (std::exception& e) {
82951       {
82952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82953       };
82954     } catch (Dali::DaliException e) {
82955       {
82956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82957       };
82958     } catch (...) {
82959       {
82960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82961       };
82962     }
82963   }
82964
82965   jresult = (void *)result;
82966   return jresult;
82967 }
82968
82969
82970 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_1(void * jarg1) {
82971   void * jresult ;
82972   Dali::Toolkit::TableView *arg1 = 0 ;
82973   Dali::Toolkit::TableView *result = 0 ;
82974
82975   arg1 = (Dali::Toolkit::TableView *)jarg1;
82976   if (!arg1) {
82977     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
82978     return 0;
82979   }
82980   {
82981     try {
82982       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView((Dali::Toolkit::TableView const &)*arg1);
82983     } catch (std::out_of_range& e) {
82984       {
82985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82986       };
82987     } catch (std::exception& e) {
82988       {
82989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82990       };
82991     } catch (Dali::DaliException e) {
82992       {
82993         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82994       };
82995     } catch (...) {
82996       {
82997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82998       };
82999     }
83000   }
83001
83002   jresult = (void *)result;
83003   return jresult;
83004 }
83005
83006
83007 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_Assign(void * jarg1, void * jarg2) {
83008   void * jresult ;
83009   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83010   Dali::Toolkit::TableView *arg2 = 0 ;
83011   Dali::Toolkit::TableView *result = 0 ;
83012
83013   arg1 = (Dali::Toolkit::TableView *)jarg1;
83014   arg2 = (Dali::Toolkit::TableView *)jarg2;
83015   if (!arg2) {
83016     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
83017     return 0;
83018   }
83019   {
83020     try {
83021       result = (Dali::Toolkit::TableView *) &(arg1)->operator =((Dali::Toolkit::TableView const &)*arg2);
83022     } catch (std::out_of_range& e) {
83023       {
83024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83025       };
83026     } catch (std::exception& e) {
83027       {
83028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83029       };
83030     } catch (Dali::DaliException e) {
83031       {
83032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83033       };
83034     } catch (...) {
83035       {
83036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83037       };
83038     }
83039   }
83040
83041   jresult = (void *)result;
83042   return jresult;
83043 }
83044
83045
83046 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView(void * jarg1) {
83047   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83048
83049   arg1 = (Dali::Toolkit::TableView *)jarg1;
83050   {
83051     try {
83052       delete arg1;
83053     } catch (std::out_of_range& e) {
83054       {
83055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83056       };
83057     } catch (std::exception& e) {
83058       {
83059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83060       };
83061     } catch (Dali::DaliException e) {
83062       {
83063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83064       };
83065     } catch (...) {
83066       {
83067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83068       };
83069     }
83070   }
83071
83072 }
83073
83074
83075 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_New(unsigned int jarg1, unsigned int jarg2) {
83076   void * jresult ;
83077   unsigned int arg1 ;
83078   unsigned int arg2 ;
83079   Dali::Toolkit::TableView result;
83080
83081   arg1 = (unsigned int)jarg1;
83082   arg2 = (unsigned int)jarg2;
83083   {
83084     try {
83085       result = Dali::Toolkit::TableView::New(arg1,arg2);
83086     } catch (std::out_of_range& e) {
83087       {
83088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83089       };
83090     } catch (std::exception& e) {
83091       {
83092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83093       };
83094     } catch (Dali::DaliException e) {
83095       {
83096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83097       };
83098     } catch (...) {
83099       {
83100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83101       };
83102     }
83103   }
83104
83105   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
83106   return jresult;
83107 }
83108
83109
83110 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_DownCast(void * jarg1) {
83111   void * jresult ;
83112   Dali::BaseHandle arg1 ;
83113   Dali::BaseHandle *argp1 ;
83114   Dali::Toolkit::TableView result;
83115
83116   argp1 = (Dali::BaseHandle *)jarg1;
83117   if (!argp1) {
83118     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
83119     return 0;
83120   }
83121   arg1 = *argp1;
83122   {
83123     try {
83124       result = Dali::Toolkit::TableView::DownCast(arg1);
83125     } catch (std::out_of_range& e) {
83126       {
83127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83128       };
83129     } catch (std::exception& e) {
83130       {
83131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83132       };
83133     } catch (Dali::DaliException e) {
83134       {
83135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83136       };
83137     } catch (...) {
83138       {
83139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83140       };
83141     }
83142   }
83143
83144   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
83145   return jresult;
83146 }
83147
83148
83149 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_AddChild(void * jarg1, void * jarg2, void * jarg3) {
83150   unsigned int jresult ;
83151   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83152   Dali::Actor arg2 ;
83153   Dali::Toolkit::TableView::CellPosition arg3 ;
83154   Dali::Actor *argp2 ;
83155   Dali::Toolkit::TableView::CellPosition *argp3 ;
83156   bool result;
83157
83158   arg1 = (Dali::Toolkit::TableView *)jarg1;
83159   argp2 = (Dali::Actor *)jarg2;
83160   if (!argp2) {
83161     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83162     return 0;
83163   }
83164   arg2 = *argp2;
83165   argp3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
83166   if (!argp3) {
83167     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
83168     return 0;
83169   }
83170   arg3 = *argp3;
83171   {
83172     try {
83173       result = (bool)(arg1)->AddChild(arg2,arg3);
83174     } catch (std::out_of_range& e) {
83175       {
83176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83177       };
83178     } catch (std::exception& e) {
83179       {
83180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83181       };
83182     } catch (Dali::DaliException e) {
83183       {
83184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83185       };
83186     } catch (...) {
83187       {
83188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83189       };
83190     }
83191   }
83192
83193   jresult = result;
83194   return jresult;
83195 }
83196
83197
83198 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetChildAt(void * jarg1, void * jarg2) {
83199   void * jresult ;
83200   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83201   Dali::Toolkit::TableView::CellPosition arg2 ;
83202   Dali::Toolkit::TableView::CellPosition *argp2 ;
83203   Dali::Actor result;
83204
83205   arg1 = (Dali::Toolkit::TableView *)jarg1;
83206   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
83207   if (!argp2) {
83208     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
83209     return 0;
83210   }
83211   arg2 = *argp2;
83212   {
83213     try {
83214       result = (arg1)->GetChildAt(arg2);
83215     } catch (std::out_of_range& e) {
83216       {
83217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83218       };
83219     } catch (std::exception& e) {
83220       {
83221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83222       };
83223     } catch (Dali::DaliException e) {
83224       {
83225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83226       };
83227     } catch (...) {
83228       {
83229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83230       };
83231     }
83232   }
83233
83234   jresult = new Dali::Actor((const Dali::Actor &)result);
83235   return jresult;
83236 }
83237
83238
83239 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_RemoveChildAt(void * jarg1, void * jarg2) {
83240   void * jresult ;
83241   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83242   Dali::Toolkit::TableView::CellPosition arg2 ;
83243   Dali::Toolkit::TableView::CellPosition *argp2 ;
83244   Dali::Actor result;
83245
83246   arg1 = (Dali::Toolkit::TableView *)jarg1;
83247   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
83248   if (!argp2) {
83249     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
83250     return 0;
83251   }
83252   arg2 = *argp2;
83253   {
83254     try {
83255       result = (arg1)->RemoveChildAt(arg2);
83256     } catch (std::out_of_range& e) {
83257       {
83258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83259       };
83260     } catch (std::exception& e) {
83261       {
83262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83263       };
83264     } catch (Dali::DaliException e) {
83265       {
83266         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83267       };
83268     } catch (...) {
83269       {
83270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83271       };
83272     }
83273   }
83274
83275   jresult = new Dali::Actor((const Dali::Actor &)result);
83276   return jresult;
83277 }
83278
83279
83280 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_FindChildPosition(void * jarg1, void * jarg2, void * jarg3) {
83281   unsigned int jresult ;
83282   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83283   Dali::Actor arg2 ;
83284   Dali::Toolkit::TableView::CellPosition *arg3 = 0 ;
83285   Dali::Actor *argp2 ;
83286   bool result;
83287
83288   arg1 = (Dali::Toolkit::TableView *)jarg1;
83289   argp2 = (Dali::Actor *)jarg2;
83290   if (!argp2) {
83291     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83292     return 0;
83293   }
83294   arg2 = *argp2;
83295   arg3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
83296   if (!arg3) {
83297     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView::CellPosition & type is null", 0);
83298     return 0;
83299   }
83300   {
83301     try {
83302       result = (bool)(arg1)->FindChildPosition(arg2,*arg3);
83303     } catch (std::out_of_range& e) {
83304       {
83305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83306       };
83307     } catch (std::exception& e) {
83308       {
83309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83310       };
83311     } catch (Dali::DaliException e) {
83312       {
83313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83314       };
83315     } catch (...) {
83316       {
83317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83318       };
83319     }
83320   }
83321
83322   jresult = result;
83323   return jresult;
83324 }
83325
83326
83327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertRow(void * jarg1, unsigned int jarg2) {
83328   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83329   unsigned int arg2 ;
83330
83331   arg1 = (Dali::Toolkit::TableView *)jarg1;
83332   arg2 = (unsigned int)jarg2;
83333   {
83334     try {
83335       (arg1)->InsertRow(arg2);
83336     } catch (std::out_of_range& e) {
83337       {
83338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83339       };
83340     } catch (std::exception& e) {
83341       {
83342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83343       };
83344     } catch (Dali::DaliException e) {
83345       {
83346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83347       };
83348     } catch (...) {
83349       {
83350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83351       };
83352     }
83353   }
83354
83355 }
83356
83357
83358 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_0(void * jarg1, unsigned int jarg2) {
83359   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83360   unsigned int arg2 ;
83361
83362   arg1 = (Dali::Toolkit::TableView *)jarg1;
83363   arg2 = (unsigned int)jarg2;
83364   {
83365     try {
83366       (arg1)->DeleteRow(arg2);
83367     } catch (std::out_of_range& e) {
83368       {
83369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83370       };
83371     } catch (std::exception& e) {
83372       {
83373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83374       };
83375     } catch (Dali::DaliException e) {
83376       {
83377         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83378       };
83379     } catch (...) {
83380       {
83381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83382       };
83383     }
83384   }
83385
83386 }
83387
83388
83389 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
83390   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83391   unsigned int arg2 ;
83392   std::vector< Dali::Actor > *arg3 = 0 ;
83393
83394   arg1 = (Dali::Toolkit::TableView *)jarg1;
83395   arg2 = (unsigned int)jarg2;
83396   arg3 = (std::vector< Dali::Actor > *)jarg3;
83397   if (!arg3) {
83398     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
83399     return ;
83400   }
83401   {
83402     try {
83403       (arg1)->DeleteRow(arg2,*arg3);
83404     } catch (std::out_of_range& e) {
83405       {
83406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83407       };
83408     } catch (std::exception& e) {
83409       {
83410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83411       };
83412     } catch (Dali::DaliException e) {
83413       {
83414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83415       };
83416     } catch (...) {
83417       {
83418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83419       };
83420     }
83421   }
83422
83423 }
83424
83425
83426 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertColumn(void * jarg1, unsigned int jarg2) {
83427   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83428   unsigned int arg2 ;
83429
83430   arg1 = (Dali::Toolkit::TableView *)jarg1;
83431   arg2 = (unsigned int)jarg2;
83432   {
83433     try {
83434       (arg1)->InsertColumn(arg2);
83435     } catch (std::out_of_range& e) {
83436       {
83437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83438       };
83439     } catch (std::exception& e) {
83440       {
83441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83442       };
83443     } catch (Dali::DaliException e) {
83444       {
83445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83446       };
83447     } catch (...) {
83448       {
83449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83450       };
83451     }
83452   }
83453
83454 }
83455
83456
83457 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_0(void * jarg1, unsigned int jarg2) {
83458   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83459   unsigned int arg2 ;
83460
83461   arg1 = (Dali::Toolkit::TableView *)jarg1;
83462   arg2 = (unsigned int)jarg2;
83463   {
83464     try {
83465       (arg1)->DeleteColumn(arg2);
83466     } catch (std::out_of_range& e) {
83467       {
83468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83469       };
83470     } catch (std::exception& e) {
83471       {
83472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83473       };
83474     } catch (Dali::DaliException e) {
83475       {
83476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83477       };
83478     } catch (...) {
83479       {
83480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83481       };
83482     }
83483   }
83484
83485 }
83486
83487
83488 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
83489   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83490   unsigned int arg2 ;
83491   std::vector< Dali::Actor > *arg3 = 0 ;
83492
83493   arg1 = (Dali::Toolkit::TableView *)jarg1;
83494   arg2 = (unsigned int)jarg2;
83495   arg3 = (std::vector< Dali::Actor > *)jarg3;
83496   if (!arg3) {
83497     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
83498     return ;
83499   }
83500   {
83501     try {
83502       (arg1)->DeleteColumn(arg2,*arg3);
83503     } catch (std::out_of_range& e) {
83504       {
83505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83506       };
83507     } catch (std::exception& e) {
83508       {
83509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83510       };
83511     } catch (Dali::DaliException e) {
83512       {
83513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83514       };
83515     } catch (...) {
83516       {
83517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83518       };
83519     }
83520   }
83521
83522 }
83523
83524
83525 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
83526   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83527   unsigned int arg2 ;
83528   unsigned int arg3 ;
83529
83530   arg1 = (Dali::Toolkit::TableView *)jarg1;
83531   arg2 = (unsigned int)jarg2;
83532   arg3 = (unsigned int)jarg3;
83533   {
83534     try {
83535       (arg1)->Resize(arg2,arg3);
83536     } catch (std::out_of_range& e) {
83537       {
83538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83539       };
83540     } catch (std::exception& e) {
83541       {
83542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83543       };
83544     } catch (Dali::DaliException e) {
83545       {
83546         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83547       };
83548     } catch (...) {
83549       {
83550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83551       };
83552     }
83553   }
83554
83555 }
83556
83557
83558 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4) {
83559   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83560   unsigned int arg2 ;
83561   unsigned int arg3 ;
83562   std::vector< Dali::Actor > *arg4 = 0 ;
83563
83564   arg1 = (Dali::Toolkit::TableView *)jarg1;
83565   arg2 = (unsigned int)jarg2;
83566   arg3 = (unsigned int)jarg3;
83567   arg4 = (std::vector< Dali::Actor > *)jarg4;
83568   if (!arg4) {
83569     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
83570     return ;
83571   }
83572   {
83573     try {
83574       (arg1)->Resize(arg2,arg3,*arg4);
83575     } catch (std::out_of_range& e) {
83576       {
83577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83578       };
83579     } catch (std::exception& e) {
83580       {
83581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83582       };
83583     } catch (Dali::DaliException e) {
83584       {
83585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83586       };
83587     } catch (...) {
83588       {
83589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83590       };
83591     }
83592   }
83593
83594 }
83595
83596
83597 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellPadding(void * jarg1, void * jarg2) {
83598   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83599   Dali::Size arg2 ;
83600   Dali::Size *argp2 ;
83601
83602   arg1 = (Dali::Toolkit::TableView *)jarg1;
83603   argp2 = (Dali::Size *)jarg2;
83604   if (!argp2) {
83605     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
83606     return ;
83607   }
83608   arg2 = *argp2;
83609   {
83610     try {
83611       (arg1)->SetCellPadding(arg2);
83612     } catch (std::out_of_range& e) {
83613       {
83614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83615       };
83616     } catch (std::exception& e) {
83617       {
83618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83619       };
83620     } catch (Dali::DaliException e) {
83621       {
83622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83623       };
83624     } catch (...) {
83625       {
83626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83627       };
83628     }
83629   }
83630
83631 }
83632
83633
83634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetCellPadding(void * jarg1) {
83635   void * jresult ;
83636   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83637   Dali::Size result;
83638
83639   arg1 = (Dali::Toolkit::TableView *)jarg1;
83640   {
83641     try {
83642       result = (arg1)->GetCellPadding();
83643     } catch (std::out_of_range& e) {
83644       {
83645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83646       };
83647     } catch (std::exception& e) {
83648       {
83649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83650       };
83651     } catch (Dali::DaliException e) {
83652       {
83653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83654       };
83655     } catch (...) {
83656       {
83657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83658       };
83659     }
83660   }
83661
83662   jresult = new Dali::Size((const Dali::Size &)result);
83663   return jresult;
83664 }
83665
83666
83667 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitHeight(void * jarg1, unsigned int jarg2) {
83668   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83669   unsigned int arg2 ;
83670
83671   arg1 = (Dali::Toolkit::TableView *)jarg1;
83672   arg2 = (unsigned int)jarg2;
83673   {
83674     try {
83675       (arg1)->SetFitHeight(arg2);
83676     } catch (std::out_of_range& e) {
83677       {
83678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83679       };
83680     } catch (std::exception& e) {
83681       {
83682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83683       };
83684     } catch (Dali::DaliException e) {
83685       {
83686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83687       };
83688     } catch (...) {
83689       {
83690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83691       };
83692     }
83693   }
83694
83695 }
83696
83697
83698 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitHeight(void * jarg1, unsigned int jarg2) {
83699   unsigned int jresult ;
83700   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83701   unsigned int arg2 ;
83702   bool result;
83703
83704   arg1 = (Dali::Toolkit::TableView *)jarg1;
83705   arg2 = (unsigned int)jarg2;
83706   {
83707     try {
83708       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitHeight(arg2);
83709     } catch (std::out_of_range& e) {
83710       {
83711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83712       };
83713     } catch (std::exception& e) {
83714       {
83715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83716       };
83717     } catch (Dali::DaliException e) {
83718       {
83719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83720       };
83721     } catch (...) {
83722       {
83723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83724       };
83725     }
83726   }
83727
83728   jresult = result;
83729   return jresult;
83730 }
83731
83732
83733 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitWidth(void * jarg1, unsigned int jarg2) {
83734   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83735   unsigned int arg2 ;
83736
83737   arg1 = (Dali::Toolkit::TableView *)jarg1;
83738   arg2 = (unsigned int)jarg2;
83739   {
83740     try {
83741       (arg1)->SetFitWidth(arg2);
83742     } catch (std::out_of_range& e) {
83743       {
83744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83745       };
83746     } catch (std::exception& e) {
83747       {
83748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83749       };
83750     } catch (Dali::DaliException e) {
83751       {
83752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83753       };
83754     } catch (...) {
83755       {
83756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83757       };
83758     }
83759   }
83760
83761 }
83762
83763
83764 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitWidth(void * jarg1, unsigned int jarg2) {
83765   unsigned int jresult ;
83766   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83767   unsigned int arg2 ;
83768   bool result;
83769
83770   arg1 = (Dali::Toolkit::TableView *)jarg1;
83771   arg2 = (unsigned int)jarg2;
83772   {
83773     try {
83774       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitWidth(arg2);
83775     } catch (std::out_of_range& e) {
83776       {
83777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83778       };
83779     } catch (std::exception& e) {
83780       {
83781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83782       };
83783     } catch (Dali::DaliException e) {
83784       {
83785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83786       };
83787     } catch (...) {
83788       {
83789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83790       };
83791     }
83792   }
83793
83794   jresult = result;
83795   return jresult;
83796 }
83797
83798
83799 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedHeight(void * jarg1, unsigned int jarg2, float jarg3) {
83800   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83801   unsigned int arg2 ;
83802   float arg3 ;
83803
83804   arg1 = (Dali::Toolkit::TableView *)jarg1;
83805   arg2 = (unsigned int)jarg2;
83806   arg3 = (float)jarg3;
83807   {
83808     try {
83809       (arg1)->SetFixedHeight(arg2,arg3);
83810     } catch (std::out_of_range& e) {
83811       {
83812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83813       };
83814     } catch (std::exception& e) {
83815       {
83816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83817       };
83818     } catch (Dali::DaliException e) {
83819       {
83820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83821       };
83822     } catch (...) {
83823       {
83824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83825       };
83826     }
83827   }
83828
83829 }
83830
83831
83832 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedHeight(void * jarg1, unsigned int jarg2) {
83833   float jresult ;
83834   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83835   unsigned int arg2 ;
83836   float result;
83837
83838   arg1 = (Dali::Toolkit::TableView *)jarg1;
83839   arg2 = (unsigned int)jarg2;
83840   {
83841     try {
83842       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedHeight(arg2);
83843     } catch (std::out_of_range& e) {
83844       {
83845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83846       };
83847     } catch (std::exception& e) {
83848       {
83849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83850       };
83851     } catch (Dali::DaliException e) {
83852       {
83853         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83854       };
83855     } catch (...) {
83856       {
83857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83858       };
83859     }
83860   }
83861
83862   jresult = result;
83863   return jresult;
83864 }
83865
83866
83867 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeHeight(void * jarg1, unsigned int jarg2, float jarg3) {
83868   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83869   unsigned int arg2 ;
83870   float arg3 ;
83871
83872   arg1 = (Dali::Toolkit::TableView *)jarg1;
83873   arg2 = (unsigned int)jarg2;
83874   arg3 = (float)jarg3;
83875   {
83876     try {
83877       (arg1)->SetRelativeHeight(arg2,arg3);
83878     } catch (std::out_of_range& e) {
83879       {
83880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83881       };
83882     } catch (std::exception& e) {
83883       {
83884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83885       };
83886     } catch (Dali::DaliException e) {
83887       {
83888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83889       };
83890     } catch (...) {
83891       {
83892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83893       };
83894     }
83895   }
83896
83897 }
83898
83899
83900 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeHeight(void * jarg1, unsigned int jarg2) {
83901   float jresult ;
83902   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83903   unsigned int arg2 ;
83904   float result;
83905
83906   arg1 = (Dali::Toolkit::TableView *)jarg1;
83907   arg2 = (unsigned int)jarg2;
83908   {
83909     try {
83910       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeHeight(arg2);
83911     } catch (std::out_of_range& e) {
83912       {
83913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83914       };
83915     } catch (std::exception& e) {
83916       {
83917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83918       };
83919     } catch (Dali::DaliException e) {
83920       {
83921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83922       };
83923     } catch (...) {
83924       {
83925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83926       };
83927     }
83928   }
83929
83930   jresult = result;
83931   return jresult;
83932 }
83933
83934
83935 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedWidth(void * jarg1, unsigned int jarg2, float jarg3) {
83936   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83937   unsigned int arg2 ;
83938   float arg3 ;
83939
83940   arg1 = (Dali::Toolkit::TableView *)jarg1;
83941   arg2 = (unsigned int)jarg2;
83942   arg3 = (float)jarg3;
83943   {
83944     try {
83945       (arg1)->SetFixedWidth(arg2,arg3);
83946     } catch (std::out_of_range& e) {
83947       {
83948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83949       };
83950     } catch (std::exception& e) {
83951       {
83952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83953       };
83954     } catch (Dali::DaliException e) {
83955       {
83956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83957       };
83958     } catch (...) {
83959       {
83960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83961       };
83962     }
83963   }
83964
83965 }
83966
83967
83968 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedWidth(void * jarg1, unsigned int jarg2) {
83969   float jresult ;
83970   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83971   unsigned int arg2 ;
83972   float result;
83973
83974   arg1 = (Dali::Toolkit::TableView *)jarg1;
83975   arg2 = (unsigned int)jarg2;
83976   {
83977     try {
83978       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedWidth(arg2);
83979     } catch (std::out_of_range& e) {
83980       {
83981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83982       };
83983     } catch (std::exception& e) {
83984       {
83985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83986       };
83987     } catch (Dali::DaliException e) {
83988       {
83989         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83990       };
83991     } catch (...) {
83992       {
83993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83994       };
83995     }
83996   }
83997
83998   jresult = result;
83999   return jresult;
84000 }
84001
84002
84003 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeWidth(void * jarg1, unsigned int jarg2, float jarg3) {
84004   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
84005   unsigned int arg2 ;
84006   float arg3 ;
84007
84008   arg1 = (Dali::Toolkit::TableView *)jarg1;
84009   arg2 = (unsigned int)jarg2;
84010   arg3 = (float)jarg3;
84011   {
84012     try {
84013       (arg1)->SetRelativeWidth(arg2,arg3);
84014     } catch (std::out_of_range& e) {
84015       {
84016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84017       };
84018     } catch (std::exception& e) {
84019       {
84020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84021       };
84022     } catch (Dali::DaliException e) {
84023       {
84024         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84025       };
84026     } catch (...) {
84027       {
84028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84029       };
84030     }
84031   }
84032
84033 }
84034
84035
84036 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeWidth(void * jarg1, unsigned int jarg2) {
84037   float jresult ;
84038   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
84039   unsigned int arg2 ;
84040   float result;
84041
84042   arg1 = (Dali::Toolkit::TableView *)jarg1;
84043   arg2 = (unsigned int)jarg2;
84044   {
84045     try {
84046       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeWidth(arg2);
84047     } catch (std::out_of_range& e) {
84048       {
84049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84050       };
84051     } catch (std::exception& e) {
84052       {
84053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84054       };
84055     } catch (Dali::DaliException e) {
84056       {
84057         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84058       };
84059     } catch (...) {
84060       {
84061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84062       };
84063     }
84064   }
84065
84066   jresult = result;
84067   return jresult;
84068 }
84069
84070
84071 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetRows(void * jarg1) {
84072   unsigned int jresult ;
84073   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
84074   unsigned int result;
84075
84076   arg1 = (Dali::Toolkit::TableView *)jarg1;
84077   {
84078     try {
84079       result = (unsigned int)(arg1)->GetRows();
84080     } catch (std::out_of_range& e) {
84081       {
84082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84083       };
84084     } catch (std::exception& e) {
84085       {
84086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84087       };
84088     } catch (Dali::DaliException e) {
84089       {
84090         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84091       };
84092     } catch (...) {
84093       {
84094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84095       };
84096     }
84097   }
84098
84099   jresult = result;
84100   return jresult;
84101 }
84102
84103
84104 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetColumns(void * jarg1) {
84105   unsigned int jresult ;
84106   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
84107   unsigned int result;
84108
84109   arg1 = (Dali::Toolkit::TableView *)jarg1;
84110   {
84111     try {
84112       result = (unsigned int)(arg1)->GetColumns();
84113     } catch (std::out_of_range& e) {
84114       {
84115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84116       };
84117     } catch (std::exception& e) {
84118       {
84119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84120       };
84121     } catch (Dali::DaliException e) {
84122       {
84123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84124       };
84125     } catch (...) {
84126       {
84127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84128       };
84129     }
84130   }
84131
84132   jresult = result;
84133   return jresult;
84134 }
84135
84136
84137 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellAlignment(void * jarg1, void * jarg2, int jarg3, int jarg4) {
84138   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
84139   Dali::Toolkit::TableView::CellPosition arg2 ;
84140   Dali::HorizontalAlignment::Type arg3 ;
84141   Dali::VerticalAlignment::Type arg4 ;
84142   Dali::Toolkit::TableView::CellPosition *argp2 ;
84143
84144   arg1 = (Dali::Toolkit::TableView *)jarg1;
84145   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
84146   if (!argp2) {
84147     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
84148     return ;
84149   }
84150   arg2 = *argp2;
84151   arg3 = (Dali::HorizontalAlignment::Type)jarg3;
84152   arg4 = (Dali::VerticalAlignment::Type)jarg4;
84153   {
84154     try {
84155       (arg1)->SetCellAlignment(arg2,arg3,arg4);
84156     } catch (std::out_of_range& e) {
84157       {
84158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84159       };
84160     } catch (std::exception& e) {
84161       {
84162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84163       };
84164     } catch (Dali::DaliException e) {
84165       {
84166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84167       };
84168     } catch (...) {
84169       {
84170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84171       };
84172     }
84173   }
84174
84175 }
84176
84177
84178 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DEFAULT_RENDERING_BACKEND_get() {
84179   unsigned int jresult ;
84180   unsigned int result;
84181
84182   result = (unsigned int)(unsigned int)Dali::Toolkit::Text::DEFAULT_RENDERING_BACKEND;
84183   jresult = result;
84184   return jresult;
84185 }
84186
84187
84188 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_RENDERING_BACKEND_get() {
84189   int jresult ;
84190   int result;
84191
84192   result = (int)Dali::Toolkit::TextLabel::Property::RENDERING_BACKEND;
84193   jresult = (int)result;
84194   return jresult;
84195 }
84196
84197
84198 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_get() {
84199   int jresult ;
84200   int result;
84201
84202   result = (int)Dali::Toolkit::TextLabel::Property::TEXT;
84203   jresult = (int)result;
84204   return jresult;
84205 }
84206
84207
84208 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_FAMILY_get() {
84209   int jresult ;
84210   int result;
84211
84212   result = (int)Dali::Toolkit::TextLabel::Property::FONT_FAMILY;
84213   jresult = (int)result;
84214   return jresult;
84215 }
84216
84217
84218 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_STYLE_get() {
84219   int jresult ;
84220   int result;
84221
84222   result = (int)Dali::Toolkit::TextLabel::Property::FONT_STYLE;
84223   jresult = (int)result;
84224   return jresult;
84225 }
84226
84227
84228 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_POINT_SIZE_get() {
84229   int jresult ;
84230   int result;
84231
84232   result = (int)Dali::Toolkit::TextLabel::Property::POINT_SIZE;
84233   jresult = (int)result;
84234   return jresult;
84235 }
84236
84237
84238 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_MULTI_LINE_get() {
84239   int jresult ;
84240   int result;
84241
84242   result = (int)Dali::Toolkit::TextLabel::Property::MULTI_LINE;
84243   jresult = (int)result;
84244   return jresult;
84245 }
84246
84247
84248 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_HORIZONTAL_ALIGNMENT_get() {
84249   int jresult ;
84250   int result;
84251
84252   result = (int)Dali::Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT;
84253   jresult = (int)result;
84254   return jresult;
84255 }
84256
84257
84258 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_VERTICAL_ALIGNMENT_get() {
84259   int jresult ;
84260   int result;
84261
84262   result = (int)Dali::Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT;
84263   jresult = (int)result;
84264   return jresult;
84265 }
84266
84267
84268 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_COLOR_get() {
84269   int jresult ;
84270   int result;
84271
84272   result = (int)Dali::Toolkit::TextLabel::Property::TEXT_COLOR;
84273   jresult = (int)result;
84274   return jresult;
84275 }
84276
84277 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_OFFSET_get() {
84278   int jresult ;
84279   int result;
84280
84281   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW_OFFSET;
84282   jresult = (int)result;
84283   return jresult;
84284 }
84285
84286
84287 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_COLOR_get() {
84288   int jresult ;
84289   int result;
84290
84291   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW_COLOR;
84292   jresult = (int)result;
84293   return jresult;
84294 }
84295
84296
84297 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_ENABLED_get() {
84298   int jresult ;
84299   int result;
84300
84301   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_ENABLED;
84302   jresult = (int)result;
84303   return jresult;
84304 }
84305
84306
84307 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_COLOR_get() {
84308   int jresult ;
84309   int result;
84310
84311   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_COLOR;
84312   jresult = (int)result;
84313   return jresult;
84314 }
84315
84316
84317 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_HEIGHT_get() {
84318   int jresult ;
84319   int result;
84320
84321   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_HEIGHT;
84322   jresult = (int)result;
84323   return jresult;
84324 }
84325
84326
84327 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_MARKUP_get() {
84328   int jresult ;
84329   int result;
84330
84331   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_MARKUP;
84332   jresult = (int)result;
84333   return jresult;
84334 }
84335
84336
84337 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_AUTO_SCROLL_get() {
84338   int jresult ;
84339   int result;
84340
84341   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_AUTO_SCROLL;
84342   jresult = (int)result;
84343   return jresult;
84344 }
84345
84346
84347 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_SPEED_get() {
84348   int jresult ;
84349   int result;
84350
84351   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_SPEED;
84352   jresult = (int)result;
84353   return jresult;
84354 }
84355
84356
84357 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_LOOP_COUNT_get() {
84358   int jresult ;
84359   int result;
84360
84361   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_LOOP_COUNT;
84362   jresult = (int)result;
84363   return jresult;
84364 }
84365
84366
84367 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_GAP_get() {
84368   int jresult ;
84369   int result;
84370
84371   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_GAP;
84372   jresult = (int)result;
84373   return jresult;
84374 }
84375
84376
84377 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_LINE_SPACING_get() {
84378   int jresult ;
84379   int result;
84380
84381   result = (int)Dali::Toolkit::TextLabel::Property::LINE_SPACING;
84382   jresult = (int)result;
84383   return jresult;
84384 }
84385
84386
84387 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_get() {
84388   int jresult ;
84389   int result;
84390
84391   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE;
84392   jresult = (int)result;
84393   return jresult;
84394 }
84395
84396
84397 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_get() {
84398   int jresult ;
84399   int result;
84400
84401   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW;
84402   jresult = (int)result;
84403   return jresult;
84404 }
84405
84406
84407 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_EMBOSS_get() {
84408   int jresult ;
84409   int result;
84410
84411   result = (int)Dali::Toolkit::TextLabel::Property::EMBOSS;
84412   jresult = (int)result;
84413   return jresult;
84414 }
84415
84416
84417 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_OUTLINE_get() {
84418   int jresult ;
84419   int result;
84420
84421   result = (int)Dali::Toolkit::TextLabel::Property::OUTLINE;
84422   jresult = (int)result;
84423   return jresult;
84424 }
84425
84426
84427 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel_Property() {
84428   void * jresult ;
84429   Dali::Toolkit::TextLabel::Property *result = 0 ;
84430
84431   {
84432     try {
84433       result = (Dali::Toolkit::TextLabel::Property *)new Dali::Toolkit::TextLabel::Property();
84434     } catch (std::out_of_range& e) {
84435       {
84436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84437       };
84438     } catch (std::exception& e) {
84439       {
84440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84441       };
84442     } catch (Dali::DaliException e) {
84443       {
84444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84445       };
84446     } catch (...) {
84447       {
84448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84449       };
84450     }
84451   }
84452
84453   jresult = (void *)result;
84454   return jresult;
84455 }
84456
84457
84458 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel_Property(void * jarg1) {
84459   Dali::Toolkit::TextLabel::Property *arg1 = (Dali::Toolkit::TextLabel::Property *) 0 ;
84460
84461   arg1 = (Dali::Toolkit::TextLabel::Property *)jarg1;
84462   {
84463     try {
84464       delete arg1;
84465     } catch (std::out_of_range& e) {
84466       {
84467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84468       };
84469     } catch (std::exception& e) {
84470       {
84471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84472       };
84473     } catch (Dali::DaliException e) {
84474       {
84475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84476       };
84477     } catch (...) {
84478       {
84479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84480       };
84481     }
84482   }
84483
84484 }
84485
84486
84487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_0() {
84488   void * jresult ;
84489   Dali::Toolkit::TextLabel result;
84490
84491   {
84492     try {
84493       result = Dali::Toolkit::TextLabel::New();
84494     } catch (std::out_of_range& e) {
84495       {
84496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84497       };
84498     } catch (std::exception& e) {
84499       {
84500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84501       };
84502     } catch (Dali::DaliException e) {
84503       {
84504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84505       };
84506     } catch (...) {
84507       {
84508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84509       };
84510     }
84511   }
84512
84513   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
84514   return jresult;
84515 }
84516
84517
84518 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_1(char * jarg1) {
84519   void * jresult ;
84520   std::string *arg1 = 0 ;
84521   Dali::Toolkit::TextLabel result;
84522
84523   if (!jarg1) {
84524     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
84525     return 0;
84526   }
84527   std::string arg1_str(jarg1);
84528   arg1 = &arg1_str;
84529   {
84530     try {
84531       result = Dali::Toolkit::TextLabel::New((std::string const &)*arg1);
84532     } catch (std::out_of_range& e) {
84533       {
84534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84535       };
84536     } catch (std::exception& e) {
84537       {
84538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84539       };
84540     } catch (Dali::DaliException e) {
84541       {
84542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84543       };
84544     } catch (...) {
84545       {
84546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84547       };
84548     }
84549   }
84550
84551   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
84552
84553   //argout typemap for const std::string&
84554
84555   return jresult;
84556 }
84557
84558
84559 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_0() {
84560   void * jresult ;
84561   Dali::Toolkit::TextLabel *result = 0 ;
84562
84563   {
84564     try {
84565       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel();
84566     } catch (std::out_of_range& e) {
84567       {
84568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84569       };
84570     } catch (std::exception& e) {
84571       {
84572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84573       };
84574     } catch (Dali::DaliException e) {
84575       {
84576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84577       };
84578     } catch (...) {
84579       {
84580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84581       };
84582     }
84583   }
84584
84585   jresult = (void *)result;
84586   return jresult;
84587 }
84588
84589
84590 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_1(void * jarg1) {
84591   void * jresult ;
84592   Dali::Toolkit::TextLabel *arg1 = 0 ;
84593   Dali::Toolkit::TextLabel *result = 0 ;
84594
84595   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
84596   if (!arg1) {
84597     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
84598     return 0;
84599   }
84600   {
84601     try {
84602       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel((Dali::Toolkit::TextLabel const &)*arg1);
84603     } catch (std::out_of_range& e) {
84604       {
84605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84606       };
84607     } catch (std::exception& e) {
84608       {
84609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84610       };
84611     } catch (Dali::DaliException e) {
84612       {
84613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84614       };
84615     } catch (...) {
84616       {
84617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84618       };
84619     }
84620   }
84621
84622   jresult = (void *)result;
84623   return jresult;
84624 }
84625
84626
84627 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_Assign(void * jarg1, void * jarg2) {
84628   void * jresult ;
84629   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
84630   Dali::Toolkit::TextLabel *arg2 = 0 ;
84631   Dali::Toolkit::TextLabel *result = 0 ;
84632
84633   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
84634   arg2 = (Dali::Toolkit::TextLabel *)jarg2;
84635   if (!arg2) {
84636     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
84637     return 0;
84638   }
84639   {
84640     try {
84641       result = (Dali::Toolkit::TextLabel *) &(arg1)->operator =((Dali::Toolkit::TextLabel const &)*arg2);
84642     } catch (std::out_of_range& e) {
84643       {
84644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84645       };
84646     } catch (std::exception& e) {
84647       {
84648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84649       };
84650     } catch (Dali::DaliException e) {
84651       {
84652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84653       };
84654     } catch (...) {
84655       {
84656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84657       };
84658     }
84659   }
84660
84661   jresult = (void *)result;
84662   return jresult;
84663 }
84664
84665
84666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel(void * jarg1) {
84667   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
84668
84669   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
84670   {
84671     try {
84672       delete arg1;
84673     } catch (std::out_of_range& e) {
84674       {
84675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84676       };
84677     } catch (std::exception& e) {
84678       {
84679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84680       };
84681     } catch (Dali::DaliException e) {
84682       {
84683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84684       };
84685     } catch (...) {
84686       {
84687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84688       };
84689     }
84690   }
84691
84692 }
84693
84694
84695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_DownCast(void * jarg1) {
84696   void * jresult ;
84697   Dali::BaseHandle arg1 ;
84698   Dali::BaseHandle *argp1 ;
84699   Dali::Toolkit::TextLabel result;
84700
84701   argp1 = (Dali::BaseHandle *)jarg1;
84702   if (!argp1) {
84703     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
84704     return 0;
84705   }
84706   arg1 = *argp1;
84707   {
84708     try {
84709       result = Dali::Toolkit::TextLabel::DownCast(arg1);
84710     } catch (std::out_of_range& e) {
84711       {
84712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84713       };
84714     } catch (std::exception& e) {
84715       {
84716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84717       };
84718     } catch (Dali::DaliException e) {
84719       {
84720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84721       };
84722     } catch (...) {
84723       {
84724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84725       };
84726     }
84727   }
84728
84729   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
84730   return jresult;
84731 }
84732
84733
84734 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityManager() {
84735   void * jresult ;
84736   Dali::Toolkit::AccessibilityManager *result = 0 ;
84737
84738   {
84739     try {
84740       result = (Dali::Toolkit::AccessibilityManager *)new Dali::Toolkit::AccessibilityManager();
84741     } catch (std::out_of_range& e) {
84742       {
84743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84744       };
84745     } catch (std::exception& e) {
84746       {
84747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84748       };
84749     } catch (Dali::DaliException e) {
84750       {
84751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84752       };
84753     } catch (...) {
84754       {
84755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84756       };
84757     }
84758   }
84759
84760   jresult = (void *)result;
84761   return jresult;
84762 }
84763
84764
84765 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityManager(void * jarg1) {
84766   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84767
84768   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84769   {
84770     try {
84771       delete arg1;
84772     } catch (std::out_of_range& e) {
84773       {
84774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84775       };
84776     } catch (std::exception& e) {
84777       {
84778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84779       };
84780     } catch (Dali::DaliException e) {
84781       {
84782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84783       };
84784     } catch (...) {
84785       {
84786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84787       };
84788     }
84789   }
84790
84791 }
84792
84793
84794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_Get() {
84795   void * jresult ;
84796   Dali::Toolkit::AccessibilityManager result;
84797
84798   {
84799     try {
84800       result = Dali::Toolkit::AccessibilityManager::Get();
84801     } catch (std::out_of_range& e) {
84802       {
84803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84804       };
84805     } catch (std::exception& e) {
84806       {
84807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84808       };
84809     } catch (Dali::DaliException e) {
84810       {
84811         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84812       };
84813     } catch (...) {
84814       {
84815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84816       };
84817     }
84818   }
84819
84820   jresult = new Dali::Toolkit::AccessibilityManager((const Dali::Toolkit::AccessibilityManager &)result);
84821   return jresult;
84822 }
84823
84824
84825 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3, char * jarg4) {
84826   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84827   Dali::Actor arg2 ;
84828   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
84829   std::string *arg4 = 0 ;
84830   Dali::Actor *argp2 ;
84831
84832   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84833   argp2 = (Dali::Actor *)jarg2;
84834   if (!argp2) {
84835     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84836     return ;
84837   }
84838   arg2 = *argp2;
84839   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
84840   if (!jarg4) {
84841     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
84842     return ;
84843   }
84844   std::string arg4_str(jarg4);
84845   arg4 = &arg4_str;
84846   {
84847     try {
84848       (arg1)->SetAccessibilityAttribute(arg2,arg3,(std::string const &)*arg4);
84849     } catch (std::out_of_range& e) {
84850       {
84851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84852       };
84853     } catch (std::exception& e) {
84854       {
84855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84856       };
84857     } catch (Dali::DaliException e) {
84858       {
84859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84860       };
84861     } catch (...) {
84862       {
84863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84864       };
84865     }
84866   }
84867
84868
84869   //argout typemap for const std::string&
84870
84871 }
84872
84873
84874 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3) {
84875   char * jresult ;
84876   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84877   Dali::Actor arg2 ;
84878   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
84879   Dali::Actor *argp2 ;
84880   std::string result;
84881
84882   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84883   argp2 = (Dali::Actor *)jarg2;
84884   if (!argp2) {
84885     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84886     return 0;
84887   }
84888   arg2 = *argp2;
84889   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
84890   {
84891     try {
84892       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetAccessibilityAttribute(arg2,arg3);
84893     } catch (std::out_of_range& e) {
84894       {
84895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84896       };
84897     } catch (std::exception& e) {
84898       {
84899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84900       };
84901     } catch (Dali::DaliException e) {
84902       {
84903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84904       };
84905     } catch (...) {
84906       {
84907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84908       };
84909     }
84910   }
84911
84912   jresult = SWIG_csharp_string_callback((&result)->c_str());
84913   return jresult;
84914 }
84915
84916
84917 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusOrder(void * jarg1, void * jarg2, unsigned int jarg3) {
84918   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84919   Dali::Actor arg2 ;
84920   unsigned int arg3 ;
84921   Dali::Actor *argp2 ;
84922
84923   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84924   argp2 = (Dali::Actor *)jarg2;
84925   if (!argp2) {
84926     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84927     return ;
84928   }
84929   arg2 = *argp2;
84930   arg3 = (unsigned int)jarg3;
84931   {
84932     try {
84933       (arg1)->SetFocusOrder(arg2,arg3);
84934     } catch (std::out_of_range& e) {
84935       {
84936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84937       };
84938     } catch (std::exception& e) {
84939       {
84940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84941       };
84942     } catch (Dali::DaliException e) {
84943       {
84944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84945       };
84946     } catch (...) {
84947       {
84948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84949       };
84950     }
84951   }
84952
84953 }
84954
84955
84956 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusOrder(void * jarg1, void * jarg2) {
84957   unsigned int jresult ;
84958   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84959   Dali::Actor arg2 ;
84960   Dali::Actor *argp2 ;
84961   unsigned int result;
84962
84963   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84964   argp2 = (Dali::Actor *)jarg2;
84965   if (!argp2) {
84966     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84967     return 0;
84968   }
84969   arg2 = *argp2;
84970   {
84971     try {
84972       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetFocusOrder(arg2);
84973     } catch (std::out_of_range& e) {
84974       {
84975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84976       };
84977     } catch (std::exception& e) {
84978       {
84979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84980       };
84981     } catch (Dali::DaliException e) {
84982       {
84983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84984       };
84985     } catch (...) {
84986       {
84987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84988       };
84989     }
84990   }
84991
84992   jresult = result;
84993   return jresult;
84994 }
84995
84996
84997 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GenerateNewFocusOrder(void * jarg1) {
84998   unsigned int jresult ;
84999   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85000   unsigned int result;
85001
85002   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85003   {
85004     try {
85005       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GenerateNewFocusOrder();
85006     } catch (std::out_of_range& e) {
85007       {
85008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85009       };
85010     } catch (std::exception& e) {
85011       {
85012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85013       };
85014     } catch (Dali::DaliException e) {
85015       {
85016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85017       };
85018     } catch (...) {
85019       {
85020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85021       };
85022     }
85023   }
85024
85025   jresult = result;
85026   return jresult;
85027 }
85028
85029
85030 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetActorByFocusOrder(void * jarg1, unsigned int jarg2) {
85031   void * jresult ;
85032   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85033   unsigned int arg2 ;
85034   Dali::Actor result;
85035
85036   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85037   arg2 = (unsigned int)jarg2;
85038   {
85039     try {
85040       result = (arg1)->GetActorByFocusOrder(arg2);
85041     } catch (std::out_of_range& e) {
85042       {
85043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85044       };
85045     } catch (std::exception& e) {
85046       {
85047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85048       };
85049     } catch (Dali::DaliException e) {
85050       {
85051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85052       };
85053     } catch (...) {
85054       {
85055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85056       };
85057     }
85058   }
85059
85060   jresult = new Dali::Actor((const Dali::Actor &)result);
85061   return jresult;
85062 }
85063
85064
85065 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetCurrentFocusActor(void * jarg1, void * jarg2) {
85066   unsigned int jresult ;
85067   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85068   Dali::Actor arg2 ;
85069   Dali::Actor *argp2 ;
85070   bool result;
85071
85072   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85073   argp2 = (Dali::Actor *)jarg2;
85074   if (!argp2) {
85075     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85076     return 0;
85077   }
85078   arg2 = *argp2;
85079   {
85080     try {
85081       result = (bool)(arg1)->SetCurrentFocusActor(arg2);
85082     } catch (std::out_of_range& e) {
85083       {
85084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85085       };
85086     } catch (std::exception& e) {
85087       {
85088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85089       };
85090     } catch (Dali::DaliException e) {
85091       {
85092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85093       };
85094     } catch (...) {
85095       {
85096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85097       };
85098     }
85099   }
85100
85101   jresult = result;
85102   return jresult;
85103 }
85104
85105
85106 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusActor(void * jarg1) {
85107   void * jresult ;
85108   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85109   Dali::Actor result;
85110
85111   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85112   {
85113     try {
85114       result = (arg1)->GetCurrentFocusActor();
85115     } catch (std::out_of_range& e) {
85116       {
85117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85118       };
85119     } catch (std::exception& e) {
85120       {
85121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85122       };
85123     } catch (Dali::DaliException e) {
85124       {
85125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85126       };
85127     } catch (...) {
85128       {
85129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85130       };
85131     }
85132   }
85133
85134   jresult = new Dali::Actor((const Dali::Actor &)result);
85135   return jresult;
85136 }
85137
85138
85139 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusGroup(void * jarg1) {
85140   void * jresult ;
85141   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85142   Dali::Actor result;
85143
85144   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85145   {
85146     try {
85147       result = (arg1)->GetCurrentFocusGroup();
85148     } catch (std::out_of_range& e) {
85149       {
85150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85151       };
85152     } catch (std::exception& e) {
85153       {
85154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85155       };
85156     } catch (Dali::DaliException e) {
85157       {
85158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85159       };
85160     } catch (...) {
85161       {
85162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85163       };
85164     }
85165   }
85166
85167   jresult = new Dali::Actor((const Dali::Actor &)result);
85168   return jresult;
85169 }
85170
85171
85172 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusOrder(void * jarg1) {
85173   unsigned int jresult ;
85174   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85175   unsigned int result;
85176
85177   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85178   {
85179     try {
85180       result = (unsigned int)(arg1)->GetCurrentFocusOrder();
85181     } catch (std::out_of_range& e) {
85182       {
85183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85184       };
85185     } catch (std::exception& e) {
85186       {
85187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85188       };
85189     } catch (Dali::DaliException e) {
85190       {
85191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85192       };
85193     } catch (...) {
85194       {
85195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85196       };
85197     }
85198   }
85199
85200   jresult = result;
85201   return jresult;
85202 }
85203
85204
85205 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusForward(void * jarg1) {
85206   unsigned int jresult ;
85207   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85208   bool result;
85209
85210   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85211   {
85212     try {
85213       result = (bool)(arg1)->MoveFocusForward();
85214     } catch (std::out_of_range& e) {
85215       {
85216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85217       };
85218     } catch (std::exception& e) {
85219       {
85220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85221       };
85222     } catch (Dali::DaliException e) {
85223       {
85224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85225       };
85226     } catch (...) {
85227       {
85228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85229       };
85230     }
85231   }
85232
85233   jresult = result;
85234   return jresult;
85235 }
85236
85237
85238 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusBackward(void * jarg1) {
85239   unsigned int jresult ;
85240   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85241   bool result;
85242
85243   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85244   {
85245     try {
85246       result = (bool)(arg1)->MoveFocusBackward();
85247     } catch (std::out_of_range& e) {
85248       {
85249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85250       };
85251     } catch (std::exception& e) {
85252       {
85253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85254       };
85255     } catch (Dali::DaliException e) {
85256       {
85257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85258       };
85259     } catch (...) {
85260       {
85261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85262       };
85263     }
85264   }
85265
85266   jresult = result;
85267   return jresult;
85268 }
85269
85270
85271 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_ClearFocus(void * jarg1) {
85272   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85273
85274   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85275   {
85276     try {
85277       (arg1)->ClearFocus();
85278     } catch (std::out_of_range& e) {
85279       {
85280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85281       };
85282     } catch (std::exception& e) {
85283       {
85284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85285       };
85286     } catch (Dali::DaliException e) {
85287       {
85288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85289       };
85290     } catch (...) {
85291       {
85292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85293       };
85294     }
85295   }
85296
85297 }
85298
85299
85300 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_Reset(void * jarg1) {
85301   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85302
85303   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85304   {
85305     try {
85306       (arg1)->Reset();
85307     } catch (std::out_of_range& e) {
85308       {
85309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85310       };
85311     } catch (std::exception& e) {
85312       {
85313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85314       };
85315     } catch (Dali::DaliException e) {
85316       {
85317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85318       };
85319     } catch (...) {
85320       {
85321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85322       };
85323     }
85324   }
85325
85326 }
85327
85328
85329 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusGroup(void * jarg1, void * jarg2, unsigned int jarg3) {
85330   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85331   Dali::Actor arg2 ;
85332   bool arg3 ;
85333   Dali::Actor *argp2 ;
85334
85335   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85336   argp2 = (Dali::Actor *)jarg2;
85337   if (!argp2) {
85338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85339     return ;
85340   }
85341   arg2 = *argp2;
85342   arg3 = jarg3 ? true : false;
85343   {
85344     try {
85345       (arg1)->SetFocusGroup(arg2,arg3);
85346     } catch (std::out_of_range& e) {
85347       {
85348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85349       };
85350     } catch (std::exception& e) {
85351       {
85352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85353       };
85354     } catch (Dali::DaliException e) {
85355       {
85356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85357       };
85358     } catch (...) {
85359       {
85360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85361       };
85362     }
85363   }
85364
85365 }
85366
85367
85368 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_IsFocusGroup(void * jarg1, void * jarg2) {
85369   unsigned int jresult ;
85370   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85371   Dali::Actor arg2 ;
85372   Dali::Actor *argp2 ;
85373   bool result;
85374
85375   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85376   argp2 = (Dali::Actor *)jarg2;
85377   if (!argp2) {
85378     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85379     return 0;
85380   }
85381   arg2 = *argp2;
85382   {
85383     try {
85384       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->IsFocusGroup(arg2);
85385     } catch (std::out_of_range& e) {
85386       {
85387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85388       };
85389     } catch (std::exception& e) {
85390       {
85391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85392       };
85393     } catch (Dali::DaliException e) {
85394       {
85395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85396       };
85397     } catch (...) {
85398       {
85399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85400       };
85401     }
85402   }
85403
85404   jresult = result;
85405   return jresult;
85406 }
85407
85408
85409 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetGroupMode(void * jarg1, unsigned int jarg2) {
85410   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85411   bool arg2 ;
85412
85413   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85414   arg2 = jarg2 ? true : false;
85415   {
85416     try {
85417       (arg1)->SetGroupMode(arg2);
85418     } catch (std::out_of_range& e) {
85419       {
85420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85421       };
85422     } catch (std::exception& e) {
85423       {
85424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85425       };
85426     } catch (Dali::DaliException e) {
85427       {
85428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85429       };
85430     } catch (...) {
85431       {
85432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85433       };
85434     }
85435   }
85436
85437 }
85438
85439
85440 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetGroupMode(void * jarg1) {
85441   unsigned int jresult ;
85442   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85443   bool result;
85444
85445   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85446   {
85447     try {
85448       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetGroupMode();
85449     } catch (std::out_of_range& e) {
85450       {
85451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85452       };
85453     } catch (std::exception& e) {
85454       {
85455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85456       };
85457     } catch (Dali::DaliException e) {
85458       {
85459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85460       };
85461     } catch (...) {
85462       {
85463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85464       };
85465     }
85466   }
85467
85468   jresult = result;
85469   return jresult;
85470 }
85471
85472
85473 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetWrapMode(void * jarg1, unsigned int jarg2) {
85474   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85475   bool arg2 ;
85476
85477   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85478   arg2 = jarg2 ? true : false;
85479   {
85480     try {
85481       (arg1)->SetWrapMode(arg2);
85482     } catch (std::out_of_range& e) {
85483       {
85484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85485       };
85486     } catch (std::exception& e) {
85487       {
85488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85489       };
85490     } catch (Dali::DaliException e) {
85491       {
85492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85493       };
85494     } catch (...) {
85495       {
85496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85497       };
85498     }
85499   }
85500
85501 }
85502
85503
85504 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetWrapMode(void * jarg1) {
85505   unsigned int jresult ;
85506   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85507   bool result;
85508
85509   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85510   {
85511     try {
85512       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetWrapMode();
85513     } catch (std::out_of_range& e) {
85514       {
85515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85516       };
85517     } catch (std::exception& e) {
85518       {
85519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85520       };
85521     } catch (Dali::DaliException e) {
85522       {
85523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85524       };
85525     } catch (...) {
85526       {
85527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85528       };
85529     }
85530   }
85531
85532   jresult = result;
85533   return jresult;
85534 }
85535
85536
85537 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusIndicatorActor(void * jarg1, void * jarg2) {
85538   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85539   Dali::Actor arg2 ;
85540   Dali::Actor *argp2 ;
85541
85542   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85543   argp2 = (Dali::Actor *)jarg2;
85544   if (!argp2) {
85545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85546     return ;
85547   }
85548   arg2 = *argp2;
85549   {
85550     try {
85551       (arg1)->SetFocusIndicatorActor(arg2);
85552     } catch (std::out_of_range& e) {
85553       {
85554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85555       };
85556     } catch (std::exception& e) {
85557       {
85558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85559       };
85560     } catch (Dali::DaliException e) {
85561       {
85562         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85563       };
85564     } catch (...) {
85565       {
85566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85567       };
85568     }
85569   }
85570
85571 }
85572
85573
85574 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusIndicatorActor(void * jarg1) {
85575   void * jresult ;
85576   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85577   Dali::Actor result;
85578
85579   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85580   {
85581     try {
85582       result = (arg1)->GetFocusIndicatorActor();
85583     } catch (std::out_of_range& e) {
85584       {
85585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85586       };
85587     } catch (std::exception& e) {
85588       {
85589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85590       };
85591     } catch (Dali::DaliException e) {
85592       {
85593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85594       };
85595     } catch (...) {
85596       {
85597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85598       };
85599     }
85600   }
85601
85602   jresult = new Dali::Actor((const Dali::Actor &)result);
85603   return jresult;
85604 }
85605
85606
85607 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusGroup(void * jarg1, void * jarg2) {
85608   void * jresult ;
85609   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85610   Dali::Actor arg2 ;
85611   Dali::Actor *argp2 ;
85612   Dali::Actor result;
85613
85614   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85615   argp2 = (Dali::Actor *)jarg2;
85616   if (!argp2) {
85617     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85618     return 0;
85619   }
85620   arg2 = *argp2;
85621   {
85622     try {
85623       result = (arg1)->GetFocusGroup(arg2);
85624     } catch (std::out_of_range& e) {
85625       {
85626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85627       };
85628     } catch (std::exception& e) {
85629       {
85630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85631       };
85632     } catch (Dali::DaliException e) {
85633       {
85634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85635       };
85636     } catch (...) {
85637       {
85638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85639       };
85640     }
85641   }
85642
85643   jresult = new Dali::Actor((const Dali::Actor &)result);
85644   return jresult;
85645 }
85646
85647
85648 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetReadPosition(void * jarg1) {
85649   void * jresult ;
85650   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85651   Dali::Vector2 result;
85652
85653   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85654   {
85655     try {
85656       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetReadPosition();
85657     } catch (std::out_of_range& e) {
85658       {
85659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85660       };
85661     } catch (std::exception& e) {
85662       {
85663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85664       };
85665     } catch (Dali::DaliException e) {
85666       {
85667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85668       };
85669     } catch (...) {
85670       {
85671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85672       };
85673     }
85674   }
85675
85676   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
85677   return jresult;
85678 }
85679
85680
85681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusChangedSignal(void * jarg1) {
85682   void * jresult ;
85683   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85684   Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *result = 0 ;
85685
85686   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85687   {
85688     try {
85689       result = (Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *) &(arg1)->FocusChangedSignal();
85690     } catch (std::out_of_range& e) {
85691       {
85692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85693       };
85694     } catch (std::exception& e) {
85695       {
85696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85697       };
85698     } catch (Dali::DaliException e) {
85699       {
85700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85701       };
85702     } catch (...) {
85703       {
85704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85705       };
85706     }
85707   }
85708
85709   jresult = (void *)result;
85710   return jresult;
85711 }
85712
85713
85714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusOvershotSignal(void * jarg1) {
85715   void * jresult ;
85716   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85717   Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *result = 0 ;
85718
85719   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85720   {
85721     try {
85722       result = (Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *) &(arg1)->FocusOvershotSignal();
85723     } catch (std::out_of_range& e) {
85724       {
85725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85726       };
85727     } catch (std::exception& e) {
85728       {
85729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85730       };
85731     } catch (Dali::DaliException e) {
85732       {
85733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85734       };
85735     } catch (...) {
85736       {
85737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85738       };
85739     }
85740   }
85741
85742   jresult = (void *)result;
85743   return jresult;
85744 }
85745
85746
85747 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusedActorActivatedSignal(void * jarg1) {
85748   void * jresult ;
85749   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85750   Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *result = 0 ;
85751
85752   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85753   {
85754     try {
85755       result = (Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *) &(arg1)->FocusedActorActivatedSignal();
85756     } catch (std::out_of_range& e) {
85757       {
85758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85759       };
85760     } catch (std::exception& e) {
85761       {
85762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85763       };
85764     } catch (Dali::DaliException e) {
85765       {
85766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85767       };
85768     } catch (...) {
85769       {
85770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85771       };
85772     }
85773   }
85774
85775   jresult = (void *)result;
85776   return jresult;
85777 }
85778
85779
85780 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_StatusChangedSignal(void * jarg1) {
85781   void * jresult ;
85782   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85783   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85784
85785   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85786   {
85787     try {
85788       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->StatusChangedSignal();
85789     } catch (std::out_of_range& e) {
85790       {
85791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85792       };
85793     } catch (std::exception& e) {
85794       {
85795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85796       };
85797     } catch (Dali::DaliException e) {
85798       {
85799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85800       };
85801     } catch (...) {
85802       {
85803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85804       };
85805     }
85806   }
85807
85808   jresult = (void *)result;
85809   return jresult;
85810 }
85811
85812
85813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionNextSignal(void * jarg1) {
85814   void * jresult ;
85815   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85816   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85817
85818   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85819   {
85820     try {
85821       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionNextSignal();
85822     } catch (std::out_of_range& e) {
85823       {
85824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85825       };
85826     } catch (std::exception& e) {
85827       {
85828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85829       };
85830     } catch (Dali::DaliException e) {
85831       {
85832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85833       };
85834     } catch (...) {
85835       {
85836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85837       };
85838     }
85839   }
85840
85841   jresult = (void *)result;
85842   return jresult;
85843 }
85844
85845
85846 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPreviousSignal(void * jarg1) {
85847   void * jresult ;
85848   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85849   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85850
85851   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85852   {
85853     try {
85854       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPreviousSignal();
85855     } catch (std::out_of_range& e) {
85856       {
85857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85858       };
85859     } catch (std::exception& e) {
85860       {
85861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85862       };
85863     } catch (Dali::DaliException e) {
85864       {
85865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85866       };
85867     } catch (...) {
85868       {
85869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85870       };
85871     }
85872   }
85873
85874   jresult = (void *)result;
85875   return jresult;
85876 }
85877
85878
85879 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionActivateSignal(void * jarg1) {
85880   void * jresult ;
85881   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85882   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85883
85884   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85885   {
85886     try {
85887       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionActivateSignal();
85888     } catch (std::out_of_range& e) {
85889       {
85890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85891       };
85892     } catch (std::exception& e) {
85893       {
85894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85895       };
85896     } catch (Dali::DaliException e) {
85897       {
85898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85899       };
85900     } catch (...) {
85901       {
85902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85903       };
85904     }
85905   }
85906
85907   jresult = (void *)result;
85908   return jresult;
85909 }
85910
85911
85912 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadSignal(void * jarg1) {
85913   void * jresult ;
85914   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85915   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85916
85917   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85918   {
85919     try {
85920       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadSignal();
85921     } catch (std::out_of_range& e) {
85922       {
85923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85924       };
85925     } catch (std::exception& e) {
85926       {
85927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85928       };
85929     } catch (Dali::DaliException e) {
85930       {
85931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85932       };
85933     } catch (...) {
85934       {
85935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85936       };
85937     }
85938   }
85939
85940   jresult = (void *)result;
85941   return jresult;
85942 }
85943
85944
85945 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionOverSignal(void * jarg1) {
85946   void * jresult ;
85947   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85948   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85949
85950   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85951   {
85952     try {
85953       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionOverSignal();
85954     } catch (std::out_of_range& e) {
85955       {
85956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85957       };
85958     } catch (std::exception& e) {
85959       {
85960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85961       };
85962     } catch (Dali::DaliException e) {
85963       {
85964         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85965       };
85966     } catch (...) {
85967       {
85968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85969       };
85970     }
85971   }
85972
85973   jresult = (void *)result;
85974   return jresult;
85975 }
85976
85977
85978 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadNextSignal(void * jarg1) {
85979   void * jresult ;
85980   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85981   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85982
85983   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85984   {
85985     try {
85986       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadNextSignal();
85987     } catch (std::out_of_range& e) {
85988       {
85989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85990       };
85991     } catch (std::exception& e) {
85992       {
85993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85994       };
85995     } catch (Dali::DaliException e) {
85996       {
85997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85998       };
85999     } catch (...) {
86000       {
86001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86002       };
86003     }
86004   }
86005
86006   jresult = (void *)result;
86007   return jresult;
86008 }
86009
86010
86011 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPreviousSignal(void * jarg1) {
86012   void * jresult ;
86013   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86014   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86015
86016   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86017   {
86018     try {
86019       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPreviousSignal();
86020     } catch (std::out_of_range& e) {
86021       {
86022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86023       };
86024     } catch (std::exception& e) {
86025       {
86026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86027       };
86028     } catch (Dali::DaliException e) {
86029       {
86030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86031       };
86032     } catch (...) {
86033       {
86034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86035       };
86036     }
86037   }
86038
86039   jresult = (void *)result;
86040   return jresult;
86041 }
86042
86043
86044 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionUpSignal(void * jarg1) {
86045   void * jresult ;
86046   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86047   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86048
86049   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86050   {
86051     try {
86052       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionUpSignal();
86053     } catch (std::out_of_range& e) {
86054       {
86055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86056       };
86057     } catch (std::exception& e) {
86058       {
86059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86060       };
86061     } catch (Dali::DaliException e) {
86062       {
86063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86064       };
86065     } catch (...) {
86066       {
86067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86068       };
86069     }
86070   }
86071
86072   jresult = (void *)result;
86073   return jresult;
86074 }
86075
86076
86077 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionDownSignal(void * jarg1) {
86078   void * jresult ;
86079   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86080   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86081
86082   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86083   {
86084     try {
86085       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionDownSignal();
86086     } catch (std::out_of_range& e) {
86087       {
86088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86089       };
86090     } catch (std::exception& e) {
86091       {
86092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86093       };
86094     } catch (Dali::DaliException e) {
86095       {
86096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86097       };
86098     } catch (...) {
86099       {
86100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86101       };
86102     }
86103   }
86104
86105   jresult = (void *)result;
86106   return jresult;
86107 }
86108
86109
86110 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionClearFocusSignal(void * jarg1) {
86111   void * jresult ;
86112   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86113   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86114
86115   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86116   {
86117     try {
86118       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionClearFocusSignal();
86119     } catch (std::out_of_range& e) {
86120       {
86121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86122       };
86123     } catch (std::exception& e) {
86124       {
86125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86126       };
86127     } catch (Dali::DaliException e) {
86128       {
86129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86130       };
86131     } catch (...) {
86132       {
86133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86134       };
86135     }
86136   }
86137
86138   jresult = (void *)result;
86139   return jresult;
86140 }
86141
86142
86143 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionBackSignal(void * jarg1) {
86144   void * jresult ;
86145   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86146   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86147
86148   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86149   {
86150     try {
86151       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionBackSignal();
86152     } catch (std::out_of_range& e) {
86153       {
86154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86155       };
86156     } catch (std::exception& e) {
86157       {
86158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86159       };
86160     } catch (Dali::DaliException e) {
86161       {
86162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86163       };
86164     } catch (...) {
86165       {
86166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86167       };
86168     }
86169   }
86170
86171   jresult = (void *)result;
86172   return jresult;
86173 }
86174
86175
86176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollUpSignal(void * jarg1) {
86177   void * jresult ;
86178   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86179   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86180
86181   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86182   {
86183     try {
86184       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollUpSignal();
86185     } catch (std::out_of_range& e) {
86186       {
86187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86188       };
86189     } catch (std::exception& e) {
86190       {
86191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86192       };
86193     } catch (Dali::DaliException e) {
86194       {
86195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86196       };
86197     } catch (...) {
86198       {
86199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86200       };
86201     }
86202   }
86203
86204   jresult = (void *)result;
86205   return jresult;
86206 }
86207
86208
86209 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollDownSignal(void * jarg1) {
86210   void * jresult ;
86211   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86212   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86213
86214   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86215   {
86216     try {
86217       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollDownSignal();
86218     } catch (std::out_of_range& e) {
86219       {
86220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86221       };
86222     } catch (std::exception& e) {
86223       {
86224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86225       };
86226     } catch (Dali::DaliException e) {
86227       {
86228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86229       };
86230     } catch (...) {
86231       {
86232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86233       };
86234     }
86235   }
86236
86237   jresult = (void *)result;
86238   return jresult;
86239 }
86240
86241
86242 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageLeftSignal(void * jarg1) {
86243   void * jresult ;
86244   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86245   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86246
86247   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86248   {
86249     try {
86250       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageLeftSignal();
86251     } catch (std::out_of_range& e) {
86252       {
86253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86254       };
86255     } catch (std::exception& e) {
86256       {
86257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86258       };
86259     } catch (Dali::DaliException e) {
86260       {
86261         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86262       };
86263     } catch (...) {
86264       {
86265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86266       };
86267     }
86268   }
86269
86270   jresult = (void *)result;
86271   return jresult;
86272 }
86273
86274
86275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageRightSignal(void * jarg1) {
86276   void * jresult ;
86277   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86278   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86279
86280   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86281   {
86282     try {
86283       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageRightSignal();
86284     } catch (std::out_of_range& e) {
86285       {
86286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86287       };
86288     } catch (std::exception& e) {
86289       {
86290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86291       };
86292     } catch (Dali::DaliException e) {
86293       {
86294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86295       };
86296     } catch (...) {
86297       {
86298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86299       };
86300     }
86301   }
86302
86303   jresult = (void *)result;
86304   return jresult;
86305 }
86306
86307
86308 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageUpSignal(void * jarg1) {
86309   void * jresult ;
86310   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86311   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86312
86313   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86314   {
86315     try {
86316       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageUpSignal();
86317     } catch (std::out_of_range& e) {
86318       {
86319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86320       };
86321     } catch (std::exception& e) {
86322       {
86323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86324       };
86325     } catch (Dali::DaliException e) {
86326       {
86327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86328       };
86329     } catch (...) {
86330       {
86331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86332       };
86333     }
86334   }
86335
86336   jresult = (void *)result;
86337   return jresult;
86338 }
86339
86340
86341 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageDownSignal(void * jarg1) {
86342   void * jresult ;
86343   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86344   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86345
86346   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86347   {
86348     try {
86349       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageDownSignal();
86350     } catch (std::out_of_range& e) {
86351       {
86352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86353       };
86354     } catch (std::exception& e) {
86355       {
86356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86357       };
86358     } catch (Dali::DaliException e) {
86359       {
86360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86361       };
86362     } catch (...) {
86363       {
86364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86365       };
86366     }
86367   }
86368
86369   jresult = (void *)result;
86370   return jresult;
86371 }
86372
86373
86374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToFirstSignal(void * jarg1) {
86375   void * jresult ;
86376   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86377   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86378
86379   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86380   {
86381     try {
86382       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToFirstSignal();
86383     } catch (std::out_of_range& e) {
86384       {
86385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86386       };
86387     } catch (std::exception& e) {
86388       {
86389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86390       };
86391     } catch (Dali::DaliException e) {
86392       {
86393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86394       };
86395     } catch (...) {
86396       {
86397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86398       };
86399     }
86400   }
86401
86402   jresult = (void *)result;
86403   return jresult;
86404 }
86405
86406
86407 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToLastSignal(void * jarg1) {
86408   void * jresult ;
86409   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86410   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86411
86412   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86413   {
86414     try {
86415       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToLastSignal();
86416     } catch (std::out_of_range& e) {
86417       {
86418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86419       };
86420     } catch (std::exception& e) {
86421       {
86422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86423       };
86424     } catch (Dali::DaliException e) {
86425       {
86426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86427       };
86428     } catch (...) {
86429       {
86430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86431       };
86432     }
86433   }
86434
86435   jresult = (void *)result;
86436   return jresult;
86437 }
86438
86439
86440 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromTopSignal(void * jarg1) {
86441   void * jresult ;
86442   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86443   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86444
86445   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86446   {
86447     try {
86448       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromTopSignal();
86449     } catch (std::out_of_range& e) {
86450       {
86451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86452       };
86453     } catch (std::exception& e) {
86454       {
86455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86456       };
86457     } catch (Dali::DaliException e) {
86458       {
86459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86460       };
86461     } catch (...) {
86462       {
86463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86464       };
86465     }
86466   }
86467
86468   jresult = (void *)result;
86469   return jresult;
86470 }
86471
86472
86473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromNextSignal(void * jarg1) {
86474   void * jresult ;
86475   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86476   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86477
86478   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86479   {
86480     try {
86481       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromNextSignal();
86482     } catch (std::out_of_range& e) {
86483       {
86484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86485       };
86486     } catch (std::exception& e) {
86487       {
86488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86489       };
86490     } catch (Dali::DaliException e) {
86491       {
86492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86493       };
86494     } catch (...) {
86495       {
86496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86497       };
86498     }
86499   }
86500
86501   jresult = (void *)result;
86502   return jresult;
86503 }
86504
86505
86506 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionZoomSignal(void * jarg1) {
86507   void * jresult ;
86508   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86509   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86510
86511   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86512   {
86513     try {
86514       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionZoomSignal();
86515     } catch (std::out_of_range& e) {
86516       {
86517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86518       };
86519     } catch (std::exception& e) {
86520       {
86521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86522       };
86523     } catch (Dali::DaliException e) {
86524       {
86525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86526       };
86527     } catch (...) {
86528       {
86529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86530       };
86531     }
86532   }
86533
86534   jresult = (void *)result;
86535   return jresult;
86536 }
86537
86538
86539 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadIndicatorInformationSignal(void * jarg1) {
86540   void * jresult ;
86541   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86542   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86543
86544   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86545   {
86546     try {
86547       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadIndicatorInformationSignal();
86548     } catch (std::out_of_range& e) {
86549       {
86550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86551       };
86552     } catch (std::exception& e) {
86553       {
86554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86555       };
86556     } catch (Dali::DaliException e) {
86557       {
86558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86559       };
86560     } catch (...) {
86561       {
86562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86563       };
86564     }
86565   }
86566
86567   jresult = (void *)result;
86568   return jresult;
86569 }
86570
86571
86572 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPauseResumeSignal(void * jarg1) {
86573   void * jresult ;
86574   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86575   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86576
86577   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86578   {
86579     try {
86580       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPauseResumeSignal();
86581     } catch (std::out_of_range& e) {
86582       {
86583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86584       };
86585     } catch (std::exception& e) {
86586       {
86587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86588       };
86589     } catch (Dali::DaliException e) {
86590       {
86591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86592       };
86593     } catch (...) {
86594       {
86595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86596       };
86597     }
86598   }
86599
86600   jresult = (void *)result;
86601   return jresult;
86602 }
86603
86604
86605 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionStartStopSignal(void * jarg1) {
86606   void * jresult ;
86607   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86608   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86609
86610   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86611   {
86612     try {
86613       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionStartStopSignal();
86614     } catch (std::out_of_range& e) {
86615       {
86616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86617       };
86618     } catch (std::exception& e) {
86619       {
86620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86621       };
86622     } catch (Dali::DaliException e) {
86623       {
86624         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86625       };
86626     } catch (...) {
86627       {
86628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86629       };
86630     }
86631   }
86632
86633   jresult = (void *)result;
86634   return jresult;
86635 }
86636
86637
86638 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollSignal(void * jarg1) {
86639   void * jresult ;
86640   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86641   Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *result = 0 ;
86642
86643   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86644   {
86645     try {
86646       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *) &(arg1)->ActionScrollSignal();
86647     } catch (std::out_of_range& e) {
86648       {
86649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86650       };
86651     } catch (std::exception& e) {
86652       {
86653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86654       };
86655     } catch (Dali::DaliException e) {
86656       {
86657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86658       };
86659     } catch (...) {
86660       {
86661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86662       };
86663     }
86664   }
86665
86666   jresult = (void *)result;
86667   return jresult;
86668 }
86669
86670
86671 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleManager() {
86672   void * jresult ;
86673   Dali::Toolkit::StyleManager *result = 0 ;
86674
86675   {
86676     try {
86677       result = (Dali::Toolkit::StyleManager *)new Dali::Toolkit::StyleManager();
86678     } catch (std::out_of_range& e) {
86679       {
86680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86681       };
86682     } catch (std::exception& e) {
86683       {
86684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86685       };
86686     } catch (Dali::DaliException e) {
86687       {
86688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86689       };
86690     } catch (...) {
86691       {
86692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86693       };
86694     }
86695   }
86696
86697   jresult = (void *)result;
86698   return jresult;
86699 }
86700
86701
86702 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleManager(void * jarg1) {
86703   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86704
86705   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86706   {
86707     try {
86708       delete arg1;
86709     } catch (std::out_of_range& e) {
86710       {
86711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86712       };
86713     } catch (std::exception& e) {
86714       {
86715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86716       };
86717     } catch (Dali::DaliException e) {
86718       {
86719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86720       };
86721     } catch (...) {
86722       {
86723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86724       };
86725     }
86726   }
86727
86728 }
86729
86730
86731 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_Get() {
86732   void * jresult ;
86733   Dali::Toolkit::StyleManager result;
86734
86735   {
86736     try {
86737       result = Dali::Toolkit::StyleManager::Get();
86738     } catch (std::out_of_range& e) {
86739       {
86740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86741       };
86742     } catch (std::exception& e) {
86743       {
86744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86745       };
86746     } catch (Dali::DaliException e) {
86747       {
86748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86749       };
86750     } catch (...) {
86751       {
86752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86753       };
86754     }
86755   }
86756
86757   jresult = new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)result);
86758   return jresult;
86759 }
86760
86761
86762 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyTheme(void * jarg1, char * jarg2) {
86763   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86764   std::string *arg2 = 0 ;
86765
86766   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86767   if (!jarg2) {
86768     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86769     return ;
86770   }
86771   std::string arg2_str(jarg2);
86772   arg2 = &arg2_str;
86773   {
86774     try {
86775       (arg1)->ApplyTheme((std::string const &)*arg2);
86776     } catch (std::out_of_range& e) {
86777       {
86778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86779       };
86780     } catch (std::exception& e) {
86781       {
86782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86783       };
86784     } catch (Dali::DaliException e) {
86785       {
86786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86787       };
86788     } catch (...) {
86789       {
86790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86791       };
86792     }
86793   }
86794
86795
86796   //argout typemap for const std::string&
86797
86798 }
86799
86800
86801 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyDefaultTheme(void * jarg1) {
86802   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86803
86804   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86805   {
86806     try {
86807       (arg1)->ApplyDefaultTheme();
86808     } catch (std::out_of_range& e) {
86809       {
86810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86811       };
86812     } catch (std::exception& e) {
86813       {
86814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86815       };
86816     } catch (Dali::DaliException e) {
86817       {
86818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86819       };
86820     } catch (...) {
86821       {
86822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86823       };
86824     }
86825   }
86826
86827 }
86828
86829
86830 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_SetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
86831   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86832   std::string *arg2 = 0 ;
86833   Dali::Property::Value *arg3 = 0 ;
86834
86835   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86836   if (!jarg2) {
86837     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86838     return ;
86839   }
86840   std::string arg2_str(jarg2);
86841   arg2 = &arg2_str;
86842   arg3 = (Dali::Property::Value *)jarg3;
86843   if (!arg3) {
86844     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
86845     return ;
86846   }
86847   {
86848     try {
86849       (arg1)->SetStyleConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
86850     } catch (std::out_of_range& e) {
86851       {
86852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86853       };
86854     } catch (std::exception& e) {
86855       {
86856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86857       };
86858     } catch (Dali::DaliException e) {
86859       {
86860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86861       };
86862     } catch (...) {
86863       {
86864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86865       };
86866     }
86867   }
86868
86869
86870   //argout typemap for const std::string&
86871
86872 }
86873
86874
86875 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleManager_GetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
86876   unsigned int jresult ;
86877   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86878   std::string *arg2 = 0 ;
86879   Dali::Property::Value *arg3 = 0 ;
86880   bool result;
86881
86882   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86883   if (!jarg2) {
86884     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86885     return 0;
86886   }
86887   std::string arg2_str(jarg2);
86888   arg2 = &arg2_str;
86889   arg3 = (Dali::Property::Value *)jarg3;
86890   if (!arg3) {
86891     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value & type is null", 0);
86892     return 0;
86893   }
86894   {
86895     try {
86896       result = (bool)(arg1)->GetStyleConstant((std::string const &)*arg2,*arg3);
86897     } catch (std::out_of_range& e) {
86898       {
86899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86900       };
86901     } catch (std::exception& e) {
86902       {
86903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86904       };
86905     } catch (Dali::DaliException e) {
86906       {
86907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86908       };
86909     } catch (...) {
86910       {
86911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86912       };
86913     }
86914   }
86915
86916   jresult = result;
86917
86918   //argout typemap for const std::string&
86919
86920   return jresult;
86921 }
86922
86923
86924 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyStyle(void * jarg1, void * jarg2, char * jarg3, char * jarg4) {
86925   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86926   Dali::Toolkit::Control arg2 ;
86927   std::string *arg3 = 0 ;
86928   std::string *arg4 = 0 ;
86929   Dali::Toolkit::Control *argp2 ;
86930
86931   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86932   argp2 = (Dali::Toolkit::Control *)jarg2;
86933   if (!argp2) {
86934     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
86935     return ;
86936   }
86937   arg2 = *argp2;
86938   if (!jarg3) {
86939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86940     return ;
86941   }
86942   std::string arg3_str(jarg3);
86943   arg3 = &arg3_str;
86944   if (!jarg4) {
86945     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86946     return ;
86947   }
86948   std::string arg4_str(jarg4);
86949   arg4 = &arg4_str;
86950   {
86951     try {
86952       (arg1)->ApplyStyle(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
86953     } catch (std::out_of_range& e) {
86954       {
86955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86956       };
86957     } catch (std::exception& e) {
86958       {
86959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86960       };
86961     } catch (Dali::DaliException e) {
86962       {
86963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86964       };
86965     } catch (...) {
86966       {
86967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86968       };
86969     }
86970   }
86971
86972
86973   //argout typemap for const std::string&
86974
86975
86976   //argout typemap for const std::string&
86977
86978 }
86979
86980
86981 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_StyleChangedSignal(void * jarg1) {
86982   void * jresult ;
86983   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86984   Dali::Toolkit::StyleManager::StyleChangedSignalType *result = 0 ;
86985
86986   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86987   {
86988     try {
86989       result = (Dali::Toolkit::StyleManager::StyleChangedSignalType *) &(arg1)->StyleChangedSignal();
86990     } catch (std::out_of_range& e) {
86991       {
86992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86993       };
86994     } catch (std::exception& e) {
86995       {
86996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86997       };
86998     } catch (Dali::DaliException e) {
86999       {
87000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87001       };
87002     } catch (...) {
87003       {
87004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87005       };
87006     }
87007   }
87008
87009   jresult = (void *)result;
87010   return jresult;
87011 }
87012
87013
87014 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_LOWER_BOUND_get() {
87015   int jresult ;
87016   int result;
87017
87018   result = (int)Dali::Toolkit::Slider::Property::LOWER_BOUND;
87019   jresult = (int)result;
87020   return jresult;
87021 }
87022
87023
87024 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_UPPER_BOUND_get() {
87025   int jresult ;
87026   int result;
87027
87028   result = (int)Dali::Toolkit::Slider::Property::UPPER_BOUND;
87029   jresult = (int)result;
87030   return jresult;
87031 }
87032
87033
87034 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_get() {
87035   int jresult ;
87036   int result;
87037
87038   result = (int)Dali::Toolkit::Slider::Property::VALUE;
87039   jresult = (int)result;
87040   return jresult;
87041 }
87042
87043
87044 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_TRACK_VISUAL_get() {
87045   int jresult ;
87046   int result;
87047
87048   result = (int)Dali::Toolkit::Slider::Property::TRACK_VISUAL;
87049   jresult = (int)result;
87050   return jresult;
87051 }
87052
87053
87054 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_HANDLE_VISUAL_get() {
87055   int jresult ;
87056   int result;
87057
87058   result = (int)Dali::Toolkit::Slider::Property::HANDLE_VISUAL;
87059   jresult = (int)result;
87060   return jresult;
87061 }
87062
87063
87064 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_PROGRESS_VISUAL_get() {
87065   int jresult ;
87066   int result;
87067
87068   result = (int)Dali::Toolkit::Slider::Property::PROGRESS_VISUAL;
87069   jresult = (int)result;
87070   return jresult;
87071 }
87072
87073
87074 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_VISUAL_get() {
87075   int jresult ;
87076   int result;
87077
87078   result = (int)Dali::Toolkit::Slider::Property::POPUP_VISUAL;
87079   jresult = (int)result;
87080   return jresult;
87081 }
87082
87083
87084 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_ARROW_VISUAL_get() {
87085   int jresult ;
87086   int result;
87087
87088   result = (int)Dali::Toolkit::Slider::Property::POPUP_ARROW_VISUAL;
87089   jresult = (int)result;
87090   return jresult;
87091 }
87092
87093
87094 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_DISABLED_COLOR_get() {
87095   int jresult ;
87096   int result;
87097
87098   result = (int)Dali::Toolkit::Slider::Property::DISABLED_COLOR;
87099   jresult = (int)result;
87100   return jresult;
87101 }
87102
87103
87104 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_PRECISION_get() {
87105   int jresult ;
87106   int result;
87107
87108   result = (int)Dali::Toolkit::Slider::Property::VALUE_PRECISION;
87109   jresult = (int)result;
87110   return jresult;
87111 }
87112
87113
87114 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_POPUP_get() {
87115   int jresult ;
87116   int result;
87117
87118   result = (int)Dali::Toolkit::Slider::Property::SHOW_POPUP;
87119   jresult = (int)result;
87120   return jresult;
87121 }
87122
87123
87124 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_VALUE_get() {
87125   int jresult ;
87126   int result;
87127
87128   result = (int)Dali::Toolkit::Slider::Property::SHOW_VALUE;
87129   jresult = (int)result;
87130   return jresult;
87131 }
87132
87133
87134 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARKS_get() {
87135   int jresult ;
87136   int result;
87137
87138   result = (int)Dali::Toolkit::Slider::Property::MARKS;
87139   jresult = (int)result;
87140   return jresult;
87141 }
87142
87143
87144 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SNAP_TO_MARKS_get() {
87145   int jresult ;
87146   int result;
87147
87148   result = (int)Dali::Toolkit::Slider::Property::SNAP_TO_MARKS;
87149   jresult = (int)result;
87150   return jresult;
87151 }
87152
87153
87154 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARK_TOLERANCE_get() {
87155   int jresult ;
87156   int result;
87157
87158   result = (int)Dali::Toolkit::Slider::Property::MARK_TOLERANCE;
87159   jresult = (int)result;
87160   return jresult;
87161 }
87162
87163
87164 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider_Property() {
87165   void * jresult ;
87166   Dali::Toolkit::Slider::Property *result = 0 ;
87167
87168   {
87169     try {
87170       result = (Dali::Toolkit::Slider::Property *)new Dali::Toolkit::Slider::Property();
87171     } catch (std::out_of_range& e) {
87172       {
87173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87174       };
87175     } catch (std::exception& e) {
87176       {
87177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87178       };
87179     } catch (Dali::DaliException e) {
87180       {
87181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87182       };
87183     } catch (...) {
87184       {
87185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87186       };
87187     }
87188   }
87189
87190   jresult = (void *)result;
87191   return jresult;
87192 }
87193
87194
87195 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider_Property(void * jarg1) {
87196   Dali::Toolkit::Slider::Property *arg1 = (Dali::Toolkit::Slider::Property *) 0 ;
87197
87198   arg1 = (Dali::Toolkit::Slider::Property *)jarg1;
87199   {
87200     try {
87201       delete arg1;
87202     } catch (std::out_of_range& e) {
87203       {
87204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87205       };
87206     } catch (std::exception& e) {
87207       {
87208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87209       };
87210     } catch (Dali::DaliException e) {
87211       {
87212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87213       };
87214     } catch (...) {
87215       {
87216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87217       };
87218     }
87219   }
87220
87221 }
87222
87223
87224 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_New() {
87225   void * jresult ;
87226   Dali::Toolkit::Slider result;
87227
87228   {
87229     try {
87230       result = Dali::Toolkit::Slider::New();
87231     } catch (std::out_of_range& e) {
87232       {
87233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87234       };
87235     } catch (std::exception& e) {
87236       {
87237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87238       };
87239     } catch (Dali::DaliException e) {
87240       {
87241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87242       };
87243     } catch (...) {
87244       {
87245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87246       };
87247     }
87248   }
87249
87250   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
87251   return jresult;
87252 }
87253
87254
87255 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_0() {
87256   void * jresult ;
87257   Dali::Toolkit::Slider *result = 0 ;
87258
87259   {
87260     try {
87261       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider();
87262     } catch (std::out_of_range& e) {
87263       {
87264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87265       };
87266     } catch (std::exception& e) {
87267       {
87268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87269       };
87270     } catch (Dali::DaliException e) {
87271       {
87272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87273       };
87274     } catch (...) {
87275       {
87276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87277       };
87278     }
87279   }
87280
87281   jresult = (void *)result;
87282   return jresult;
87283 }
87284
87285
87286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_1(void * jarg1) {
87287   void * jresult ;
87288   Dali::Toolkit::Slider *arg1 = 0 ;
87289   Dali::Toolkit::Slider *result = 0 ;
87290
87291   arg1 = (Dali::Toolkit::Slider *)jarg1;
87292   if (!arg1) {
87293     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
87294     return 0;
87295   }
87296   {
87297     try {
87298       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider((Dali::Toolkit::Slider const &)*arg1);
87299     } catch (std::out_of_range& e) {
87300       {
87301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87302       };
87303     } catch (std::exception& e) {
87304       {
87305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87306       };
87307     } catch (Dali::DaliException e) {
87308       {
87309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87310       };
87311     } catch (...) {
87312       {
87313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87314       };
87315     }
87316   }
87317
87318   jresult = (void *)result;
87319   return jresult;
87320 }
87321
87322
87323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_Assign(void * jarg1, void * jarg2) {
87324   void * jresult ;
87325   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
87326   Dali::Toolkit::Slider *arg2 = 0 ;
87327   Dali::Toolkit::Slider *result = 0 ;
87328
87329   arg1 = (Dali::Toolkit::Slider *)jarg1;
87330   arg2 = (Dali::Toolkit::Slider *)jarg2;
87331   if (!arg2) {
87332     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
87333     return 0;
87334   }
87335   {
87336     try {
87337       result = (Dali::Toolkit::Slider *) &(arg1)->operator =((Dali::Toolkit::Slider const &)*arg2);
87338     } catch (std::out_of_range& e) {
87339       {
87340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87341       };
87342     } catch (std::exception& e) {
87343       {
87344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87345       };
87346     } catch (Dali::DaliException e) {
87347       {
87348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87349       };
87350     } catch (...) {
87351       {
87352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87353       };
87354     }
87355   }
87356
87357   jresult = (void *)result;
87358   return jresult;
87359 }
87360
87361
87362 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider(void * jarg1) {
87363   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
87364
87365   arg1 = (Dali::Toolkit::Slider *)jarg1;
87366   {
87367     try {
87368       delete arg1;
87369     } catch (std::out_of_range& e) {
87370       {
87371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87372       };
87373     } catch (std::exception& e) {
87374       {
87375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87376       };
87377     } catch (Dali::DaliException e) {
87378       {
87379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87380       };
87381     } catch (...) {
87382       {
87383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87384       };
87385     }
87386   }
87387
87388 }
87389
87390
87391 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_DownCast(void * jarg1) {
87392   void * jresult ;
87393   Dali::BaseHandle arg1 ;
87394   Dali::BaseHandle *argp1 ;
87395   Dali::Toolkit::Slider result;
87396
87397   argp1 = (Dali::BaseHandle *)jarg1;
87398   if (!argp1) {
87399     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
87400     return 0;
87401   }
87402   arg1 = *argp1;
87403   {
87404     try {
87405       result = Dali::Toolkit::Slider::DownCast(arg1);
87406     } catch (std::out_of_range& e) {
87407       {
87408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87409       };
87410     } catch (std::exception& e) {
87411       {
87412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87413       };
87414     } catch (Dali::DaliException e) {
87415       {
87416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87417       };
87418     } catch (...) {
87419       {
87420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87421       };
87422     }
87423   }
87424
87425   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
87426   return jresult;
87427 }
87428
87429
87430 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_ValueChangedSignal(void * jarg1) {
87431   void * jresult ;
87432   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
87433   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
87434
87435   arg1 = (Dali::Toolkit::Slider *)jarg1;
87436   {
87437     try {
87438       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
87439     } catch (std::out_of_range& e) {
87440       {
87441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87442       };
87443     } catch (std::exception& e) {
87444       {
87445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87446       };
87447     } catch (Dali::DaliException e) {
87448       {
87449         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87450       };
87451     } catch (...) {
87452       {
87453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87454       };
87455     }
87456   }
87457
87458   jresult = (void *)result;
87459   return jresult;
87460 }
87461
87462
87463 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_SlidingFinishedSignal(void * jarg1) {
87464   void * jresult ;
87465   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
87466   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
87467
87468   arg1 = (Dali::Toolkit::Slider *)jarg1;
87469   {
87470     try {
87471       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->SlidingFinishedSignal();
87472     } catch (std::out_of_range& e) {
87473       {
87474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87475       };
87476     } catch (std::exception& e) {
87477       {
87478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87479       };
87480     } catch (Dali::DaliException e) {
87481       {
87482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87483       };
87484     } catch (...) {
87485       {
87486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87487       };
87488     }
87489   }
87490
87491   jresult = (void *)result;
87492   return jresult;
87493 }
87494
87495
87496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_MarkReachedSignal(void * jarg1) {
87497   void * jresult ;
87498   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
87499   Dali::Toolkit::Slider::MarkReachedSignalType *result = 0 ;
87500
87501   arg1 = (Dali::Toolkit::Slider *)jarg1;
87502   {
87503     try {
87504       result = (Dali::Toolkit::Slider::MarkReachedSignalType *) &(arg1)->MarkReachedSignal();
87505     } catch (std::out_of_range& e) {
87506       {
87507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87508       };
87509     } catch (std::exception& e) {
87510       {
87511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87512       };
87513     } catch (Dali::DaliException e) {
87514       {
87515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87516       };
87517     } catch (...) {
87518       {
87519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87520       };
87521     }
87522   }
87523
87524   jresult = (void *)result;
87525   return jresult;
87526 }
87527
87528
87529 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VIDEO_get() {
87530   int jresult ;
87531   int result;
87532
87533   result = (int)Dali::Toolkit::VideoView::Property::VIDEO;
87534   jresult = (int)result;
87535   return jresult;
87536 }
87537
87538
87539 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_LOOPING_get() {
87540   int jresult ;
87541   int result;
87542
87543   result = (int)Dali::Toolkit::VideoView::Property::LOOPING;
87544   jresult = (int)result;
87545   return jresult;
87546 }
87547
87548
87549 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_MUTED_get() {
87550   int jresult ;
87551   int result;
87552
87553   result = (int)Dali::Toolkit::VideoView::Property::MUTED;
87554   jresult = (int)result;
87555   return jresult;
87556 }
87557
87558
87559 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VOLUME_get() {
87560   int jresult ;
87561   int result;
87562
87563   result = (int)Dali::Toolkit::VideoView::Property::VOLUME;
87564   jresult = (int)result;
87565   return jresult;
87566 }
87567
87568
87569 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_UNDERLAY_get() {
87570   int result;
87571
87572   result = (int)Dali::Toolkit::VideoView::Property::UNDERLAY;
87573
87574   return result;
87575 }
87576
87577
87578 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView_Property() {
87579   void * jresult ;
87580   Dali::Toolkit::VideoView::Property *result = 0 ;
87581
87582   {
87583     try {
87584       result = (Dali::Toolkit::VideoView::Property *)new Dali::Toolkit::VideoView::Property();
87585     } catch (std::out_of_range& e) {
87586       {
87587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87588       };
87589     } catch (std::exception& e) {
87590       {
87591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87592       };
87593     } catch (Dali::DaliException e) {
87594       {
87595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87596       };
87597     } catch (...) {
87598       {
87599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87600       };
87601     }
87602   }
87603
87604   jresult = (void *)result;
87605   return jresult;
87606 }
87607
87608
87609 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView_Property(void * jarg1) {
87610   Dali::Toolkit::VideoView::Property *arg1 = (Dali::Toolkit::VideoView::Property *) 0 ;
87611
87612   arg1 = (Dali::Toolkit::VideoView::Property *)jarg1;
87613   {
87614     try {
87615       delete arg1;
87616     } catch (std::out_of_range& e) {
87617       {
87618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87619       };
87620     } catch (std::exception& e) {
87621       {
87622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87623       };
87624     } catch (Dali::DaliException e) {
87625       {
87626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87627       };
87628     } catch (...) {
87629       {
87630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87631       };
87632     }
87633   }
87634
87635 }
87636
87637
87638 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_0() {
87639   void * jresult ;
87640   Dali::Toolkit::VideoView result;
87641
87642   {
87643     try {
87644       result = Dali::Toolkit::VideoView::New();
87645     } catch (std::out_of_range& e) {
87646       {
87647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87648       };
87649     } catch (std::exception& e) {
87650       {
87651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87652       };
87653     } catch (Dali::DaliException e) {
87654       {
87655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87656       };
87657     } catch (...) {
87658       {
87659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87660       };
87661     }
87662   }
87663
87664   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
87665   return jresult;
87666 }
87667
87668
87669 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_1(char * jarg1) {
87670   void * jresult ;
87671   std::string *arg1 = 0 ;
87672   Dali::Toolkit::VideoView result;
87673
87674   if (!jarg1) {
87675     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
87676     return 0;
87677   }
87678   std::string arg1_str(jarg1);
87679   arg1 = &arg1_str;
87680   {
87681     try {
87682       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1);
87683     } catch (std::out_of_range& e) {
87684       {
87685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87686       };
87687     } catch (std::exception& e) {
87688       {
87689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87690       };
87691     } catch (Dali::DaliException e) {
87692       {
87693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87694       };
87695     } catch (...) {
87696       {
87697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87698       };
87699     }
87700   }
87701
87702   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
87703
87704   //argout typemap for const std::string&
87705
87706   return jresult;
87707 }
87708
87709
87710 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_0() {
87711   void * jresult ;
87712   Dali::Toolkit::VideoView *result = 0 ;
87713
87714   {
87715     try {
87716       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView();
87717     } catch (std::out_of_range& e) {
87718       {
87719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87720       };
87721     } catch (std::exception& e) {
87722       {
87723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87724       };
87725     } catch (Dali::DaliException e) {
87726       {
87727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87728       };
87729     } catch (...) {
87730       {
87731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87732       };
87733     }
87734   }
87735
87736   jresult = (void *)result;
87737   return jresult;
87738 }
87739
87740
87741 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView(void * jarg1) {
87742   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87743
87744   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87745   {
87746     try {
87747       delete arg1;
87748     } catch (std::out_of_range& e) {
87749       {
87750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87751       };
87752     } catch (std::exception& e) {
87753       {
87754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87755       };
87756     } catch (Dali::DaliException e) {
87757       {
87758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87759       };
87760     } catch (...) {
87761       {
87762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87763       };
87764     }
87765   }
87766
87767 }
87768
87769
87770 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_1(void * jarg1) {
87771   void * jresult ;
87772   Dali::Toolkit::VideoView *arg1 = 0 ;
87773   Dali::Toolkit::VideoView *result = 0 ;
87774
87775   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87776   if (!arg1) {
87777     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
87778     return 0;
87779   }
87780   {
87781     try {
87782       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView((Dali::Toolkit::VideoView const &)*arg1);
87783     } catch (std::out_of_range& e) {
87784       {
87785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87786       };
87787     } catch (std::exception& e) {
87788       {
87789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87790       };
87791     } catch (Dali::DaliException e) {
87792       {
87793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87794       };
87795     } catch (...) {
87796       {
87797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87798       };
87799     }
87800   }
87801
87802   jresult = (void *)result;
87803   return jresult;
87804 }
87805
87806
87807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_Assign(void * jarg1, void * jarg2) {
87808   void * jresult ;
87809   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87810   Dali::Toolkit::VideoView *arg2 = 0 ;
87811   Dali::Toolkit::VideoView *result = 0 ;
87812
87813   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87814   arg2 = (Dali::Toolkit::VideoView *)jarg2;
87815   if (!arg2) {
87816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
87817     return 0;
87818   }
87819   {
87820     try {
87821       result = (Dali::Toolkit::VideoView *) &(arg1)->operator =((Dali::Toolkit::VideoView const &)*arg2);
87822     } catch (std::out_of_range& e) {
87823       {
87824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87825       };
87826     } catch (std::exception& e) {
87827       {
87828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87829       };
87830     } catch (Dali::DaliException e) {
87831       {
87832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87833       };
87834     } catch (...) {
87835       {
87836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87837       };
87838     }
87839   }
87840
87841   jresult = (void *)result;
87842   return jresult;
87843 }
87844
87845
87846 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_DownCast(void * jarg1) {
87847   void * jresult ;
87848   Dali::BaseHandle arg1 ;
87849   Dali::BaseHandle *argp1 ;
87850   Dali::Toolkit::VideoView result;
87851
87852   argp1 = (Dali::BaseHandle *)jarg1;
87853   if (!argp1) {
87854     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
87855     return 0;
87856   }
87857   arg1 = *argp1;
87858   {
87859     try {
87860       result = Dali::Toolkit::VideoView::DownCast(arg1);
87861     } catch (std::out_of_range& e) {
87862       {
87863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87864       };
87865     } catch (std::exception& e) {
87866       {
87867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87868       };
87869     } catch (Dali::DaliException e) {
87870       {
87871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87872       };
87873     } catch (...) {
87874       {
87875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87876       };
87877     }
87878   }
87879
87880   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
87881   return jresult;
87882 }
87883
87884
87885 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Play(void * jarg1) {
87886   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87887
87888   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87889   {
87890     try {
87891       (arg1)->Play();
87892     } catch (std::out_of_range& e) {
87893       {
87894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87895       };
87896     } catch (std::exception& e) {
87897       {
87898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87899       };
87900     } catch (Dali::DaliException e) {
87901       {
87902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87903       };
87904     } catch (...) {
87905       {
87906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87907       };
87908     }
87909   }
87910
87911 }
87912
87913
87914 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Pause(void * jarg1) {
87915   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87916
87917   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87918   {
87919     try {
87920       (arg1)->Pause();
87921     } catch (std::out_of_range& e) {
87922       {
87923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87924       };
87925     } catch (std::exception& e) {
87926       {
87927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87928       };
87929     } catch (Dali::DaliException e) {
87930       {
87931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87932       };
87933     } catch (...) {
87934       {
87935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87936       };
87937     }
87938   }
87939
87940 }
87941
87942
87943 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Stop(void * jarg1) {
87944   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87945
87946   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87947   {
87948     try {
87949       (arg1)->Stop();
87950     } catch (std::out_of_range& e) {
87951       {
87952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87953       };
87954     } catch (std::exception& e) {
87955       {
87956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87957       };
87958     } catch (Dali::DaliException e) {
87959       {
87960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87961       };
87962     } catch (...) {
87963       {
87964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87965       };
87966     }
87967   }
87968
87969 }
87970
87971
87972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Forward(void * jarg1, int jarg2) {
87973   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87974   int arg2 ;
87975
87976   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87977   arg2 = (int)jarg2;
87978   {
87979     try {
87980       (arg1)->Forward(arg2);
87981     } catch (std::out_of_range& e) {
87982       {
87983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87984       };
87985     } catch (std::exception& e) {
87986       {
87987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87988       };
87989     } catch (Dali::DaliException e) {
87990       {
87991         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87992       };
87993     } catch (...) {
87994       {
87995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87996       };
87997     }
87998   }
87999
88000 }
88001
88002
88003 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Backward(void * jarg1, int jarg2) {
88004   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
88005   int arg2 ;
88006
88007   arg1 = (Dali::Toolkit::VideoView *)jarg1;
88008   arg2 = (int)jarg2;
88009   {
88010     try {
88011       (arg1)->Backward(arg2);
88012     } catch (std::out_of_range& e) {
88013       {
88014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88015       };
88016     } catch (std::exception& e) {
88017       {
88018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88019       };
88020     } catch (Dali::DaliException e) {
88021       {
88022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88023       };
88024     } catch (...) {
88025       {
88026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88027       };
88028     }
88029   }
88030
88031 }
88032
88033
88034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_FinishedSignal(void * jarg1) {
88035   void * jresult ;
88036   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
88037   Dali::Toolkit::VideoView::VideoViewSignalType *result = 0 ;
88038
88039   arg1 = (Dali::Toolkit::VideoView *)jarg1;
88040   {
88041     try {
88042       result = (Dali::Toolkit::VideoView::VideoViewSignalType *) &(arg1)->FinishedSignal();
88043     } catch (std::out_of_range& e) {
88044       {
88045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88046       };
88047     } catch (std::exception& e) {
88048       {
88049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88050       };
88051     } catch (Dali::DaliException e) {
88052       {
88053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88054       };
88055     } catch (...) {
88056       {
88057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88058       };
88059     }
88060   }
88061
88062   jresult = (void *)result;
88063   return jresult;
88064 }
88065
88066
88067 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TITLE_get() {
88068   int jresult ;
88069   int result;
88070
88071   result = (int)Dali::Toolkit::Popup::Property::TITLE;
88072   jresult = (int)result;
88073   return jresult;
88074 }
88075
88076
88077 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTENT_get() {
88078   int jresult ;
88079   int result;
88080
88081   result = (int)Dali::Toolkit::Popup::Property::CONTENT;
88082   jresult = (int)result;
88083   return jresult;
88084 }
88085
88086
88087 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_FOOTER_get() {
88088   int jresult ;
88089   int result;
88090
88091   result = (int)Dali::Toolkit::Popup::Property::FOOTER;
88092   jresult = (int)result;
88093   return jresult;
88094 }
88095
88096
88097 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_DISPLAY_STATE_get() {
88098   int jresult ;
88099   int result;
88100
88101   result = (int)Dali::Toolkit::Popup::Property::DISPLAY_STATE;
88102   jresult = (int)result;
88103   return jresult;
88104 }
88105
88106
88107 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TOUCH_TRANSPARENT_get() {
88108   int jresult ;
88109   int result;
88110
88111   result = (int)Dali::Toolkit::Popup::Property::TOUCH_TRANSPARENT;
88112   jresult = (int)result;
88113   return jresult;
88114 }
88115
88116
88117 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_VISIBILITY_get() {
88118   int jresult ;
88119   int result;
88120
88121   result = (int)Dali::Toolkit::Popup::Property::TAIL_VISIBILITY;
88122   jresult = (int)result;
88123   return jresult;
88124 }
88125
88126
88127 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_POSITION_get() {
88128   int jresult ;
88129   int result;
88130
88131   result = (int)Dali::Toolkit::Popup::Property::TAIL_POSITION;
88132   jresult = (int)result;
88133   return jresult;
88134 }
88135
88136
88137 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTEXTUAL_MODE_get() {
88138   int jresult ;
88139   int result;
88140
88141   result = (int)Dali::Toolkit::Popup::Property::CONTEXTUAL_MODE;
88142   jresult = (int)result;
88143   return jresult;
88144 }
88145
88146
88147 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_DURATION_get() {
88148   int jresult ;
88149   int result;
88150
88151   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_DURATION;
88152   jresult = (int)result;
88153   return jresult;
88154 }
88155
88156
88157 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_MODE_get() {
88158   int jresult ;
88159   int result;
88160
88161   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_MODE;
88162   jresult = (int)result;
88163   return jresult;
88164 }
88165
88166
88167 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ENTRY_ANIMATION_get() {
88168   int jresult ;
88169   int result;
88170
88171   result = (int)Dali::Toolkit::Popup::Property::ENTRY_ANIMATION;
88172   jresult = (int)result;
88173   return jresult;
88174 }
88175
88176
88177 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_EXIT_ANIMATION_get() {
88178   int jresult ;
88179   int result;
88180
88181   result = (int)Dali::Toolkit::Popup::Property::EXIT_ANIMATION;
88182   jresult = (int)result;
88183   return jresult;
88184 }
88185
88186
88187 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_AUTO_HIDE_DELAY_get() {
88188   int jresult ;
88189   int result;
88190
88191   result = (int)Dali::Toolkit::Popup::Property::AUTO_HIDE_DELAY;
88192   jresult = (int)result;
88193   return jresult;
88194 }
88195
88196
88197 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_ENABLED_get() {
88198   int jresult ;
88199   int result;
88200
88201   result = (int)Dali::Toolkit::Popup::Property::BACKING_ENABLED;
88202   jresult = (int)result;
88203   return jresult;
88204 }
88205
88206
88207 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_COLOR_get() {
88208   int jresult ;
88209   int result;
88210
88211   result = (int)Dali::Toolkit::Popup::Property::BACKING_COLOR;
88212   jresult = (int)result;
88213   return jresult;
88214 }
88215
88216
88217 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_IMAGE_get() {
88218   int jresult ;
88219   int result;
88220
88221   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_IMAGE;
88222   jresult = (int)result;
88223   return jresult;
88224 }
88225
88226
88227 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_BORDER_get() {
88228   int jresult ;
88229   int result;
88230
88231   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_BORDER;
88232   jresult = (int)result;
88233   return jresult;
88234 }
88235
88236
88237 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_UP_IMAGE_get() {
88238   int jresult ;
88239   int result;
88240
88241   result = (int)Dali::Toolkit::Popup::Property::TAIL_UP_IMAGE;
88242   jresult = (int)result;
88243   return jresult;
88244 }
88245
88246
88247 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_DOWN_IMAGE_get() {
88248   int jresult ;
88249   int result;
88250
88251   result = (int)Dali::Toolkit::Popup::Property::TAIL_DOWN_IMAGE;
88252   jresult = (int)result;
88253   return jresult;
88254 }
88255
88256
88257 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_LEFT_IMAGE_get() {
88258   int jresult ;
88259   int result;
88260
88261   result = (int)Dali::Toolkit::Popup::Property::TAIL_LEFT_IMAGE;
88262   jresult = (int)result;
88263   return jresult;
88264 }
88265
88266
88267 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_RIGHT_IMAGE_get() {
88268   int jresult ;
88269   int result;
88270
88271   result = (int)Dali::Toolkit::Popup::Property::TAIL_RIGHT_IMAGE;
88272   jresult = (int)result;
88273   return jresult;
88274 }
88275
88276
88277 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup_Property() {
88278   void * jresult ;
88279   Dali::Toolkit::Popup::Property *result = 0 ;
88280
88281   {
88282     try {
88283       result = (Dali::Toolkit::Popup::Property *)new Dali::Toolkit::Popup::Property();
88284     } catch (std::out_of_range& e) {
88285       {
88286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88287       };
88288     } catch (std::exception& e) {
88289       {
88290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88291       };
88292     } catch (Dali::DaliException e) {
88293       {
88294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88295       };
88296     } catch (...) {
88297       {
88298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88299       };
88300     }
88301   }
88302
88303   jresult = (void *)result;
88304   return jresult;
88305 }
88306
88307
88308 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup_Property(void * jarg1) {
88309   Dali::Toolkit::Popup::Property *arg1 = (Dali::Toolkit::Popup::Property *) 0 ;
88310
88311   arg1 = (Dali::Toolkit::Popup::Property *)jarg1;
88312   {
88313     try {
88314       delete arg1;
88315     } catch (std::out_of_range& e) {
88316       {
88317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88318       };
88319     } catch (std::exception& e) {
88320       {
88321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88322       };
88323     } catch (Dali::DaliException e) {
88324       {
88325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88326       };
88327     } catch (...) {
88328       {
88329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88330       };
88331     }
88332   }
88333
88334 }
88335
88336
88337 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_0() {
88338   void * jresult ;
88339   Dali::Toolkit::Popup *result = 0 ;
88340
88341   {
88342     try {
88343       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup();
88344     } catch (std::out_of_range& e) {
88345       {
88346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88347       };
88348     } catch (std::exception& e) {
88349       {
88350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88351       };
88352     } catch (Dali::DaliException e) {
88353       {
88354         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88355       };
88356     } catch (...) {
88357       {
88358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88359       };
88360     }
88361   }
88362
88363   jresult = (void *)result;
88364   return jresult;
88365 }
88366
88367
88368 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_New() {
88369   void * jresult ;
88370   Dali::Toolkit::Popup result;
88371
88372   {
88373     try {
88374       result = Dali::Toolkit::Popup::New();
88375     } catch (std::out_of_range& e) {
88376       {
88377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88378       };
88379     } catch (std::exception& e) {
88380       {
88381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88382       };
88383     } catch (Dali::DaliException e) {
88384       {
88385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88386       };
88387     } catch (...) {
88388       {
88389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88390       };
88391     }
88392   }
88393
88394   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
88395   return jresult;
88396 }
88397
88398
88399 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup(void * jarg1) {
88400   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88401
88402   arg1 = (Dali::Toolkit::Popup *)jarg1;
88403   {
88404     try {
88405       delete arg1;
88406     } catch (std::out_of_range& e) {
88407       {
88408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88409       };
88410     } catch (std::exception& e) {
88411       {
88412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88413       };
88414     } catch (Dali::DaliException e) {
88415       {
88416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88417       };
88418     } catch (...) {
88419       {
88420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88421       };
88422     }
88423   }
88424
88425 }
88426
88427
88428 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_1(void * jarg1) {
88429   void * jresult ;
88430   Dali::Toolkit::Popup *arg1 = 0 ;
88431   Dali::Toolkit::Popup *result = 0 ;
88432
88433   arg1 = (Dali::Toolkit::Popup *)jarg1;
88434   if (!arg1) {
88435     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
88436     return 0;
88437   }
88438   {
88439     try {
88440       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup((Dali::Toolkit::Popup const &)*arg1);
88441     } catch (std::out_of_range& e) {
88442       {
88443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88444       };
88445     } catch (std::exception& e) {
88446       {
88447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88448       };
88449     } catch (Dali::DaliException e) {
88450       {
88451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88452       };
88453     } catch (...) {
88454       {
88455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88456       };
88457     }
88458   }
88459
88460   jresult = (void *)result;
88461   return jresult;
88462 }
88463
88464
88465 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_Assign(void * jarg1, void * jarg2) {
88466   void * jresult ;
88467   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88468   Dali::Toolkit::Popup *arg2 = 0 ;
88469   Dali::Toolkit::Popup *result = 0 ;
88470
88471   arg1 = (Dali::Toolkit::Popup *)jarg1;
88472   arg2 = (Dali::Toolkit::Popup *)jarg2;
88473   if (!arg2) {
88474     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
88475     return 0;
88476   }
88477   {
88478     try {
88479       result = (Dali::Toolkit::Popup *) &(arg1)->operator =((Dali::Toolkit::Popup const &)*arg2);
88480     } catch (std::out_of_range& e) {
88481       {
88482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88483       };
88484     } catch (std::exception& e) {
88485       {
88486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88487       };
88488     } catch (Dali::DaliException e) {
88489       {
88490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88491       };
88492     } catch (...) {
88493       {
88494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88495       };
88496     }
88497   }
88498
88499   jresult = (void *)result;
88500   return jresult;
88501 }
88502
88503
88504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_DownCast(void * jarg1) {
88505   void * jresult ;
88506   Dali::BaseHandle arg1 ;
88507   Dali::BaseHandle *argp1 ;
88508   Dali::Toolkit::Popup result;
88509
88510   argp1 = (Dali::BaseHandle *)jarg1;
88511   if (!argp1) {
88512     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
88513     return 0;
88514   }
88515   arg1 = *argp1;
88516   {
88517     try {
88518       result = Dali::Toolkit::Popup::DownCast(arg1);
88519     } catch (std::out_of_range& e) {
88520       {
88521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88522       };
88523     } catch (std::exception& e) {
88524       {
88525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88526       };
88527     } catch (Dali::DaliException e) {
88528       {
88529         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88530       };
88531     } catch (...) {
88532       {
88533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88534       };
88535     }
88536   }
88537
88538   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
88539   return jresult;
88540 }
88541
88542
88543 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetTitle(void * jarg1, void * jarg2) {
88544   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88545   Dali::Actor arg2 ;
88546   Dali::Actor *argp2 ;
88547
88548   arg1 = (Dali::Toolkit::Popup *)jarg1;
88549   argp2 = (Dali::Actor *)jarg2;
88550   if (!argp2) {
88551     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88552     return ;
88553   }
88554   arg2 = *argp2;
88555   {
88556     try {
88557       (arg1)->SetTitle(arg2);
88558     } catch (std::out_of_range& e) {
88559       {
88560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88561       };
88562     } catch (std::exception& e) {
88563       {
88564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88565       };
88566     } catch (Dali::DaliException e) {
88567       {
88568         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88569       };
88570     } catch (...) {
88571       {
88572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88573       };
88574     }
88575   }
88576
88577 }
88578
88579
88580 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetTitle(void * jarg1) {
88581   void * jresult ;
88582   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88583   Dali::Actor result;
88584
88585   arg1 = (Dali::Toolkit::Popup *)jarg1;
88586   {
88587     try {
88588       result = ((Dali::Toolkit::Popup const *)arg1)->GetTitle();
88589     } catch (std::out_of_range& e) {
88590       {
88591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88592       };
88593     } catch (std::exception& e) {
88594       {
88595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88596       };
88597     } catch (Dali::DaliException e) {
88598       {
88599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88600       };
88601     } catch (...) {
88602       {
88603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88604       };
88605     }
88606   }
88607
88608   jresult = new Dali::Actor((const Dali::Actor &)result);
88609   return jresult;
88610 }
88611
88612
88613 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetContent(void * jarg1, void * jarg2) {
88614   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88615   Dali::Actor arg2 ;
88616   Dali::Actor *argp2 ;
88617
88618   arg1 = (Dali::Toolkit::Popup *)jarg1;
88619   argp2 = (Dali::Actor *)jarg2;
88620   if (!argp2) {
88621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88622     return ;
88623   }
88624   arg2 = *argp2;
88625   {
88626     try {
88627       (arg1)->SetContent(arg2);
88628     } catch (std::out_of_range& e) {
88629       {
88630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88631       };
88632     } catch (std::exception& e) {
88633       {
88634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88635       };
88636     } catch (Dali::DaliException e) {
88637       {
88638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88639       };
88640     } catch (...) {
88641       {
88642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88643       };
88644     }
88645   }
88646
88647 }
88648
88649
88650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetContent(void * jarg1) {
88651   void * jresult ;
88652   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88653   Dali::Actor result;
88654
88655   arg1 = (Dali::Toolkit::Popup *)jarg1;
88656   {
88657     try {
88658       result = ((Dali::Toolkit::Popup const *)arg1)->GetContent();
88659     } catch (std::out_of_range& e) {
88660       {
88661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88662       };
88663     } catch (std::exception& e) {
88664       {
88665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88666       };
88667     } catch (Dali::DaliException e) {
88668       {
88669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88670       };
88671     } catch (...) {
88672       {
88673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88674       };
88675     }
88676   }
88677
88678   jresult = new Dali::Actor((const Dali::Actor &)result);
88679   return jresult;
88680 }
88681
88682
88683 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetFooter(void * jarg1, void * jarg2) {
88684   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88685   Dali::Actor arg2 ;
88686   Dali::Actor *argp2 ;
88687
88688   arg1 = (Dali::Toolkit::Popup *)jarg1;
88689   argp2 = (Dali::Actor *)jarg2;
88690   if (!argp2) {
88691     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88692     return ;
88693   }
88694   arg2 = *argp2;
88695   {
88696     try {
88697       (arg1)->SetFooter(arg2);
88698     } catch (std::out_of_range& e) {
88699       {
88700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88701       };
88702     } catch (std::exception& e) {
88703       {
88704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88705       };
88706     } catch (Dali::DaliException e) {
88707       {
88708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88709       };
88710     } catch (...) {
88711       {
88712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88713       };
88714     }
88715   }
88716
88717 }
88718
88719
88720 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetFooter(void * jarg1) {
88721   void * jresult ;
88722   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88723   Dali::Actor result;
88724
88725   arg1 = (Dali::Toolkit::Popup *)jarg1;
88726   {
88727     try {
88728       result = ((Dali::Toolkit::Popup const *)arg1)->GetFooter();
88729     } catch (std::out_of_range& e) {
88730       {
88731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88732       };
88733     } catch (std::exception& e) {
88734       {
88735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88736       };
88737     } catch (Dali::DaliException e) {
88738       {
88739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88740       };
88741     } catch (...) {
88742       {
88743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88744       };
88745     }
88746   }
88747
88748   jresult = new Dali::Actor((const Dali::Actor &)result);
88749   return jresult;
88750 }
88751
88752
88753 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetDisplayState(void * jarg1, int jarg2) {
88754   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88755   Dali::Toolkit::Popup::DisplayState arg2 ;
88756
88757   arg1 = (Dali::Toolkit::Popup *)jarg1;
88758   arg2 = (Dali::Toolkit::Popup::DisplayState)jarg2;
88759   {
88760     try {
88761       (arg1)->SetDisplayState(arg2);
88762     } catch (std::out_of_range& e) {
88763       {
88764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88765       };
88766     } catch (std::exception& e) {
88767       {
88768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88769       };
88770     } catch (Dali::DaliException e) {
88771       {
88772         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88773       };
88774     } catch (...) {
88775       {
88776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88777       };
88778     }
88779   }
88780
88781 }
88782
88783
88784 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_GetDisplayState(void * jarg1) {
88785   int jresult ;
88786   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88787   Dali::Toolkit::Popup::DisplayState result;
88788
88789   arg1 = (Dali::Toolkit::Popup *)jarg1;
88790   {
88791     try {
88792       result = (Dali::Toolkit::Popup::DisplayState)((Dali::Toolkit::Popup const *)arg1)->GetDisplayState();
88793     } catch (std::out_of_range& e) {
88794       {
88795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88796       };
88797     } catch (std::exception& e) {
88798       {
88799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88800       };
88801     } catch (Dali::DaliException e) {
88802       {
88803         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88804       };
88805     } catch (...) {
88806       {
88807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88808       };
88809     }
88810   }
88811
88812   jresult = (int)result;
88813   return jresult;
88814 }
88815
88816
88817 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_OutsideTouchedSignal(void * jarg1) {
88818   void * jresult ;
88819   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88820   Dali::Toolkit::Popup::TouchedOutsideSignalType *result = 0 ;
88821
88822   arg1 = (Dali::Toolkit::Popup *)jarg1;
88823   {
88824     try {
88825       result = (Dali::Toolkit::Popup::TouchedOutsideSignalType *) &(arg1)->OutsideTouchedSignal();
88826     } catch (std::out_of_range& e) {
88827       {
88828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88829       };
88830     } catch (std::exception& e) {
88831       {
88832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88833       };
88834     } catch (Dali::DaliException e) {
88835       {
88836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88837       };
88838     } catch (...) {
88839       {
88840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88841       };
88842     }
88843   }
88844
88845   jresult = (void *)result;
88846   return jresult;
88847 }
88848
88849
88850 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShowingSignal(void * jarg1) {
88851   void * jresult ;
88852   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88853   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
88854
88855   arg1 = (Dali::Toolkit::Popup *)jarg1;
88856   {
88857     try {
88858       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShowingSignal();
88859     } catch (std::out_of_range& e) {
88860       {
88861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88862       };
88863     } catch (std::exception& e) {
88864       {
88865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88866       };
88867     } catch (Dali::DaliException e) {
88868       {
88869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88870       };
88871     } catch (...) {
88872       {
88873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88874       };
88875     }
88876   }
88877
88878   jresult = (void *)result;
88879   return jresult;
88880 }
88881
88882
88883 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShownSignal(void * jarg1) {
88884   void * jresult ;
88885   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88886   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
88887
88888   arg1 = (Dali::Toolkit::Popup *)jarg1;
88889   {
88890     try {
88891       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShownSignal();
88892     } catch (std::out_of_range& e) {
88893       {
88894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88895       };
88896     } catch (std::exception& e) {
88897       {
88898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88899       };
88900     } catch (Dali::DaliException e) {
88901       {
88902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88903       };
88904     } catch (...) {
88905       {
88906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88907       };
88908     }
88909   }
88910
88911   jresult = (void *)result;
88912   return jresult;
88913 }
88914
88915
88916 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HidingSignal(void * jarg1) {
88917   void * jresult ;
88918   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88919   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
88920
88921   arg1 = (Dali::Toolkit::Popup *)jarg1;
88922   {
88923     try {
88924       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HidingSignal();
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 = (void *)result;
88945   return jresult;
88946 }
88947
88948
88949 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HiddenSignal(void * jarg1) {
88950   void * jresult ;
88951   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88952   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
88953
88954   arg1 = (Dali::Toolkit::Popup *)jarg1;
88955   {
88956     try {
88957       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HiddenSignal();
88958     } catch (std::out_of_range& e) {
88959       {
88960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88961       };
88962     } catch (std::exception& e) {
88963       {
88964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88965       };
88966     } catch (Dali::DaliException e) {
88967       {
88968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88969       };
88970     } catch (...) {
88971       {
88972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88973       };
88974     }
88975   }
88976
88977   jresult = (void *)result;
88978   return jresult;
88979 }
88980
88981
88982 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VALUE_get() {
88983   int jresult ;
88984   int result;
88985
88986   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VALUE;
88987   jresult = (int)result;
88988   return jresult;
88989 }
88990
88991
88992 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VALUE_get() {
88993   int jresult ;
88994   int result;
88995
88996   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VALUE;
88997   jresult = (int)result;
88998   return jresult;
88999 }
89000
89001
89002 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_get() {
89003   int jresult ;
89004   int result;
89005
89006   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE;
89007   jresult = (int)result;
89008   return jresult;
89009 }
89010
89011
89012 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_TRACK_VISUAL_get() {
89013   int jresult ;
89014   int result;
89015
89016   result = (int)Dali::Toolkit::ProgressBar::Property::TRACK_VISUAL;
89017   jresult = (int)result;
89018   return jresult;
89019 }
89020
89021
89022 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VISUAL_get() {
89023   int jresult ;
89024   int result;
89025
89026   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VISUAL;
89027   jresult = (int)result;
89028   return jresult;
89029 }
89030
89031
89032 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VISUAL_get() {
89033   int jresult ;
89034   int result;
89035
89036   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL;
89037   jresult = (int)result;
89038   return jresult;
89039 }
89040
89041
89042 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_get() {
89043   int jresult ;
89044   int result;
89045
89046   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL;
89047   jresult = (int)result;
89048   return jresult;
89049 }
89050
89051
89052 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_ANIMATION_get() {
89053   int jresult ;
89054   int result;
89055
89056   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL_ANIMATION;
89057   jresult = (int)result;
89058   return jresult;
89059 }
89060
89061
89062 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_LABEL_VISUAL_get() {
89063   int jresult ;
89064   int result;
89065
89066   result = (int)Dali::Toolkit::ProgressBar::Property::LABEL_VISUAL;
89067   jresult = (int)result;
89068   return jresult;
89069 }
89070
89071
89072 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar_Property() {
89073   void * jresult ;
89074   Dali::Toolkit::ProgressBar::Property *result = 0 ;
89075
89076   {
89077     try {
89078       result = (Dali::Toolkit::ProgressBar::Property *)new Dali::Toolkit::ProgressBar::Property();
89079     } catch (std::out_of_range& e) {
89080       {
89081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89082       };
89083     } catch (std::exception& e) {
89084       {
89085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89086       };
89087     } catch (Dali::DaliException e) {
89088       {
89089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89090       };
89091     } catch (...) {
89092       {
89093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89094       };
89095     }
89096   }
89097
89098   jresult = (void *)result;
89099   return jresult;
89100 }
89101
89102
89103 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar_Property(void * jarg1) {
89104   Dali::Toolkit::ProgressBar::Property *arg1 = (Dali::Toolkit::ProgressBar::Property *) 0 ;
89105
89106   arg1 = (Dali::Toolkit::ProgressBar::Property *)jarg1;
89107   {
89108     try {
89109       delete arg1;
89110     } catch (std::out_of_range& e) {
89111       {
89112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89113       };
89114     } catch (std::exception& e) {
89115       {
89116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89117       };
89118     } catch (Dali::DaliException e) {
89119       {
89120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89121       };
89122     } catch (...) {
89123       {
89124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89125       };
89126     }
89127   }
89128
89129 }
89130
89131
89132 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_New() {
89133   void * jresult ;
89134   Dali::Toolkit::ProgressBar result;
89135
89136   {
89137     try {
89138       result = Dali::Toolkit::ProgressBar::New();
89139     } catch (std::out_of_range& e) {
89140       {
89141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89142       };
89143     } catch (std::exception& e) {
89144       {
89145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89146       };
89147     } catch (Dali::DaliException e) {
89148       {
89149         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89150       };
89151     } catch (...) {
89152       {
89153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89154       };
89155     }
89156   }
89157
89158   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
89159   return jresult;
89160 }
89161
89162
89163 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_0() {
89164   void * jresult ;
89165   Dali::Toolkit::ProgressBar *result = 0 ;
89166
89167   {
89168     try {
89169       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar();
89170     } catch (std::out_of_range& e) {
89171       {
89172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89173       };
89174     } catch (std::exception& e) {
89175       {
89176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89177       };
89178     } catch (Dali::DaliException e) {
89179       {
89180         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89181       };
89182     } catch (...) {
89183       {
89184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89185       };
89186     }
89187   }
89188
89189   jresult = (void *)result;
89190   return jresult;
89191 }
89192
89193
89194 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_1(void * jarg1) {
89195   void * jresult ;
89196   Dali::Toolkit::ProgressBar *arg1 = 0 ;
89197   Dali::Toolkit::ProgressBar *result = 0 ;
89198
89199   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
89200   if (!arg1) {
89201     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
89202     return 0;
89203   }
89204   {
89205     try {
89206       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar((Dali::Toolkit::ProgressBar const &)*arg1);
89207     } catch (std::out_of_range& e) {
89208       {
89209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89210       };
89211     } catch (std::exception& e) {
89212       {
89213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89214       };
89215     } catch (Dali::DaliException e) {
89216       {
89217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89218       };
89219     } catch (...) {
89220       {
89221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89222       };
89223     }
89224   }
89225
89226   jresult = (void *)result;
89227   return jresult;
89228 }
89229
89230
89231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_Assign(void * jarg1, void * jarg2) {
89232   void * jresult ;
89233   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
89234   Dali::Toolkit::ProgressBar *arg2 = 0 ;
89235   Dali::Toolkit::ProgressBar *result = 0 ;
89236
89237   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
89238   arg2 = (Dali::Toolkit::ProgressBar *)jarg2;
89239   if (!arg2) {
89240     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
89241     return 0;
89242   }
89243   {
89244     try {
89245       result = (Dali::Toolkit::ProgressBar *) &(arg1)->operator =((Dali::Toolkit::ProgressBar const &)*arg2);
89246     } catch (std::out_of_range& e) {
89247       {
89248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89249       };
89250     } catch (std::exception& e) {
89251       {
89252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89253       };
89254     } catch (Dali::DaliException e) {
89255       {
89256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89257       };
89258     } catch (...) {
89259       {
89260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89261       };
89262     }
89263   }
89264
89265   jresult = (void *)result;
89266   return jresult;
89267 }
89268
89269
89270 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar(void * jarg1) {
89271   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
89272
89273   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
89274   {
89275     try {
89276       delete arg1;
89277     } catch (std::out_of_range& e) {
89278       {
89279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89280       };
89281     } catch (std::exception& e) {
89282       {
89283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89284       };
89285     } catch (Dali::DaliException e) {
89286       {
89287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89288       };
89289     } catch (...) {
89290       {
89291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89292       };
89293     }
89294   }
89295
89296 }
89297
89298
89299 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_DownCast(void * jarg1) {
89300   void * jresult ;
89301   Dali::BaseHandle arg1 ;
89302   Dali::BaseHandle *argp1 ;
89303   Dali::Toolkit::ProgressBar result;
89304
89305   argp1 = (Dali::BaseHandle *)jarg1;
89306   if (!argp1) {
89307     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
89308     return 0;
89309   }
89310   arg1 = *argp1;
89311   {
89312     try {
89313       result = Dali::Toolkit::ProgressBar::DownCast(arg1);
89314     } catch (std::out_of_range& e) {
89315       {
89316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89317       };
89318     } catch (std::exception& e) {
89319       {
89320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89321       };
89322     } catch (Dali::DaliException e) {
89323       {
89324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89325       };
89326     } catch (...) {
89327       {
89328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89329       };
89330     }
89331   }
89332
89333   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
89334   return jresult;
89335 }
89336
89337
89338 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_ValueChangedSignal(void * jarg1) {
89339   void * jresult ;
89340   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
89341   Dali::Toolkit::ProgressBar::ValueChangedSignalType *result = 0 ;
89342
89343   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
89344   {
89345     try {
89346       result = (Dali::Toolkit::ProgressBar::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
89347     } catch (std::out_of_range& e) {
89348       {
89349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89350       };
89351     } catch (std::exception& e) {
89352       {
89353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89354       };
89355     } catch (Dali::DaliException e) {
89356       {
89357         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89358       };
89359     } catch (...) {
89360       {
89361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89362       };
89363     }
89364   }
89365
89366   jresult = (void *)result;
89367   return jresult;
89368 }
89369
89370
89371 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_0() {
89372   void * jresult ;
89373   Dali::Toolkit::GaussianBlurView *result = 0 ;
89374
89375   {
89376     try {
89377       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView();
89378     } catch (std::out_of_range& e) {
89379       {
89380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89381       };
89382     } catch (std::exception& e) {
89383       {
89384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89385       };
89386     } catch (Dali::DaliException e) {
89387       {
89388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89389       };
89390     } catch (...) {
89391       {
89392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89393       };
89394     }
89395   }
89396
89397   jresult = (void *)result;
89398   return jresult;
89399 }
89400
89401
89402 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_1(void * jarg1) {
89403   void * jresult ;
89404   Dali::Toolkit::GaussianBlurView *arg1 = 0 ;
89405   Dali::Toolkit::GaussianBlurView *result = 0 ;
89406
89407   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89408   if (!arg1) {
89409     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
89410     return 0;
89411   }
89412   {
89413     try {
89414       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView((Dali::Toolkit::GaussianBlurView const &)*arg1);
89415     } catch (std::out_of_range& e) {
89416       {
89417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89418       };
89419     } catch (std::exception& e) {
89420       {
89421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89422       };
89423     } catch (Dali::DaliException e) {
89424       {
89425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89426       };
89427     } catch (...) {
89428       {
89429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89430       };
89431     }
89432   }
89433
89434   jresult = (void *)result;
89435   return jresult;
89436 }
89437
89438
89439 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_Assign(void * jarg1, void * jarg2) {
89440   void * jresult ;
89441   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89442   Dali::Toolkit::GaussianBlurView *arg2 = 0 ;
89443   Dali::Toolkit::GaussianBlurView *result = 0 ;
89444
89445   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89446   arg2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
89447   if (!arg2) {
89448     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
89449     return 0;
89450   }
89451   {
89452     try {
89453       result = (Dali::Toolkit::GaussianBlurView *) &(arg1)->operator =((Dali::Toolkit::GaussianBlurView const &)*arg2);
89454     } catch (std::out_of_range& e) {
89455       {
89456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89457       };
89458     } catch (std::exception& e) {
89459       {
89460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89461       };
89462     } catch (Dali::DaliException e) {
89463       {
89464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89465       };
89466     } catch (...) {
89467       {
89468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89469       };
89470     }
89471   }
89472
89473   jresult = (void *)result;
89474   return jresult;
89475 }
89476
89477
89478 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurView(void * jarg1) {
89479   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89480
89481   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89482   {
89483     try {
89484       delete arg1;
89485     } catch (std::out_of_range& e) {
89486       {
89487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89488       };
89489     } catch (std::exception& e) {
89490       {
89491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89492       };
89493     } catch (Dali::DaliException e) {
89494       {
89495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89496       };
89497     } catch (...) {
89498       {
89499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89500       };
89501     }
89502   }
89503
89504 }
89505
89506
89507 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_DownCast(void * jarg1) {
89508   void * jresult ;
89509   Dali::BaseHandle arg1 ;
89510   Dali::BaseHandle *argp1 ;
89511   Dali::Toolkit::GaussianBlurView result;
89512
89513   argp1 = (Dali::BaseHandle *)jarg1;
89514   if (!argp1) {
89515     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
89516     return 0;
89517   }
89518   arg1 = *argp1;
89519   {
89520     try {
89521       result = Dali::Toolkit::GaussianBlurView::DownCast(arg1);
89522     } catch (std::out_of_range& e) {
89523       {
89524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89525       };
89526     } catch (std::exception& e) {
89527       {
89528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89529       };
89530     } catch (Dali::DaliException e) {
89531       {
89532         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89533       };
89534     } catch (...) {
89535       {
89536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89537       };
89538     }
89539   }
89540
89541   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
89542   return jresult;
89543 }
89544
89545
89546 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_0() {
89547   void * jresult ;
89548   Dali::Toolkit::GaussianBlurView result;
89549
89550   {
89551     try {
89552       result = Dali::Toolkit::GaussianBlurView::New();
89553     } catch (std::out_of_range& e) {
89554       {
89555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89556       };
89557     } catch (std::exception& e) {
89558       {
89559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89560       };
89561     } catch (Dali::DaliException e) {
89562       {
89563         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89564       };
89565     } catch (...) {
89566       {
89567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89568       };
89569     }
89570   }
89571
89572   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
89573   return jresult;
89574 }
89575
89576
89577 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_1(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5, unsigned int jarg6) {
89578   void * jresult ;
89579   unsigned int arg1 ;
89580   float arg2 ;
89581   Dali::Pixel::Format arg3 ;
89582   float arg4 ;
89583   float arg5 ;
89584   bool arg6 ;
89585   Dali::Toolkit::GaussianBlurView result;
89586
89587   arg1 = (unsigned int)jarg1;
89588   arg2 = (float)jarg2;
89589   arg3 = (Dali::Pixel::Format)jarg3;
89590   arg4 = (float)jarg4;
89591   arg5 = (float)jarg5;
89592   arg6 = jarg6 ? true : false;
89593   {
89594     try {
89595       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5,arg6);
89596     } catch (std::out_of_range& e) {
89597       {
89598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89599       };
89600     } catch (std::exception& e) {
89601       {
89602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89603       };
89604     } catch (Dali::DaliException e) {
89605       {
89606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89607       };
89608     } catch (...) {
89609       {
89610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89611       };
89612     }
89613   }
89614
89615   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
89616   return jresult;
89617 }
89618
89619
89620 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_2(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5) {
89621   void * jresult ;
89622   unsigned int arg1 ;
89623   float arg2 ;
89624   Dali::Pixel::Format arg3 ;
89625   float arg4 ;
89626   float arg5 ;
89627   Dali::Toolkit::GaussianBlurView result;
89628
89629   arg1 = (unsigned int)jarg1;
89630   arg2 = (float)jarg2;
89631   arg3 = (Dali::Pixel::Format)jarg3;
89632   arg4 = (float)jarg4;
89633   arg5 = (float)jarg5;
89634   {
89635     try {
89636       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5);
89637     } catch (std::out_of_range& e) {
89638       {
89639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89640       };
89641     } catch (std::exception& e) {
89642       {
89643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89644       };
89645     } catch (Dali::DaliException e) {
89646       {
89647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89648       };
89649     } catch (...) {
89650       {
89651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89652       };
89653     }
89654   }
89655
89656   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
89657   return jresult;
89658 }
89659
89660
89661 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Add(void * jarg1, void * jarg2) {
89662   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89663   Dali::Actor arg2 ;
89664   Dali::Actor *argp2 ;
89665
89666   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89667   argp2 = (Dali::Actor *)jarg2;
89668   if (!argp2) {
89669     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
89670     return ;
89671   }
89672   arg2 = *argp2;
89673   {
89674     try {
89675       (arg1)->Add(arg2);
89676     } catch (std::out_of_range& e) {
89677       {
89678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89679       };
89680     } catch (std::exception& e) {
89681       {
89682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89683       };
89684     } catch (Dali::DaliException e) {
89685       {
89686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89687       };
89688     } catch (...) {
89689       {
89690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89691       };
89692     }
89693   }
89694
89695 }
89696
89697
89698 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Remove(void * jarg1, void * jarg2) {
89699   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89700   Dali::Actor arg2 ;
89701   Dali::Actor *argp2 ;
89702
89703   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89704   argp2 = (Dali::Actor *)jarg2;
89705   if (!argp2) {
89706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
89707     return ;
89708   }
89709   arg2 = *argp2;
89710   {
89711     try {
89712       (arg1)->Remove(arg2);
89713     } catch (std::out_of_range& e) {
89714       {
89715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89716       };
89717     } catch (std::exception& e) {
89718       {
89719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89720       };
89721     } catch (Dali::DaliException e) {
89722       {
89723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89724       };
89725     } catch (...) {
89726       {
89727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89728       };
89729     }
89730   }
89731
89732 }
89733
89734
89735 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Activate(void * jarg1) {
89736   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89737
89738   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89739   {
89740     try {
89741       (arg1)->Activate();
89742     } catch (std::out_of_range& e) {
89743       {
89744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89745       };
89746     } catch (std::exception& e) {
89747       {
89748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89749       };
89750     } catch (Dali::DaliException e) {
89751       {
89752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89753       };
89754     } catch (...) {
89755       {
89756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89757       };
89758     }
89759   }
89760
89761 }
89762
89763
89764 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_ActivateOnce(void * jarg1) {
89765   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89766
89767   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89768   {
89769     try {
89770       (arg1)->ActivateOnce();
89771     } catch (std::out_of_range& e) {
89772       {
89773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89774       };
89775     } catch (std::exception& e) {
89776       {
89777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89778       };
89779     } catch (Dali::DaliException e) {
89780       {
89781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89782       };
89783     } catch (...) {
89784       {
89785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89786       };
89787     }
89788   }
89789
89790 }
89791
89792
89793 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Deactivate(void * jarg1) {
89794   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89795
89796   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89797   {
89798     try {
89799       (arg1)->Deactivate();
89800     } catch (std::out_of_range& e) {
89801       {
89802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89803       };
89804     } catch (std::exception& e) {
89805       {
89806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89807       };
89808     } catch (Dali::DaliException e) {
89809       {
89810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89811       };
89812     } catch (...) {
89813       {
89814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89815       };
89816     }
89817   }
89818
89819 }
89820
89821
89822 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetUserImageAndOutputRenderTarget(void * jarg1, void * jarg2, void * jarg3) {
89823   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89824   Dali::Image arg2 ;
89825   Dali::FrameBufferImage arg3 ;
89826   Dali::Image *argp2 ;
89827   Dali::FrameBufferImage *argp3 ;
89828
89829   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89830   argp2 = (Dali::Image *)jarg2;
89831   if (!argp2) {
89832     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
89833     return ;
89834   }
89835   arg2 = *argp2;
89836   argp3 = (Dali::FrameBufferImage *)jarg3;
89837   if (!argp3) {
89838     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
89839     return ;
89840   }
89841   arg3 = *argp3;
89842   {
89843     try {
89844       (arg1)->SetUserImageAndOutputRenderTarget(arg2,arg3);
89845     } catch (std::out_of_range& e) {
89846       {
89847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89848       };
89849     } catch (std::exception& e) {
89850       {
89851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89852       };
89853     } catch (Dali::DaliException e) {
89854       {
89855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89856       };
89857     } catch (...) {
89858       {
89859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89860       };
89861     }
89862   }
89863
89864 }
89865
89866
89867 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurStrengthPropertyIndex(void * jarg1) {
89868   int jresult ;
89869   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89870   Dali::Property::Index result;
89871
89872   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89873   {
89874     try {
89875       result = (Dali::Property::Index)((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurStrengthPropertyIndex();
89876     } catch (std::out_of_range& e) {
89877       {
89878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89879       };
89880     } catch (std::exception& e) {
89881       {
89882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89883       };
89884     } catch (Dali::DaliException e) {
89885       {
89886         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89887       };
89888     } catch (...) {
89889       {
89890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89891       };
89892     }
89893   }
89894
89895   jresult = result;
89896   return jresult;
89897 }
89898
89899
89900 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurredRenderTarget(void * jarg1) {
89901   void * jresult ;
89902   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89903   Dali::FrameBufferImage result;
89904
89905   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89906   {
89907     try {
89908       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurredRenderTarget();
89909     } catch (std::out_of_range& e) {
89910       {
89911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89912       };
89913     } catch (std::exception& e) {
89914       {
89915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89916       };
89917     } catch (Dali::DaliException e) {
89918       {
89919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89920       };
89921     } catch (...) {
89922       {
89923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89924       };
89925     }
89926   }
89927
89928   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
89929   return jresult;
89930 }
89931
89932
89933 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetBackgroundColor(void * jarg1, void * jarg2) {
89934   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89935   Dali::Vector4 *arg2 = 0 ;
89936
89937   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89938   arg2 = (Dali::Vector4 *)jarg2;
89939   if (!arg2) {
89940     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
89941     return ;
89942   }
89943   {
89944     try {
89945       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
89946     } catch (std::out_of_range& e) {
89947       {
89948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89949       };
89950     } catch (std::exception& e) {
89951       {
89952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89953       };
89954     } catch (Dali::DaliException e) {
89955       {
89956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89957       };
89958     } catch (...) {
89959       {
89960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89961       };
89962     }
89963   }
89964
89965 }
89966
89967
89968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBackgroundColor(void * jarg1) {
89969   void * jresult ;
89970   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89971   Dali::Vector4 result;
89972
89973   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89974   {
89975     try {
89976       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBackgroundColor();
89977     } catch (std::out_of_range& e) {
89978       {
89979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89980       };
89981     } catch (std::exception& e) {
89982       {
89983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89984       };
89985     } catch (Dali::DaliException e) {
89986       {
89987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89988       };
89989     } catch (...) {
89990       {
89991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89992       };
89993     }
89994   }
89995
89996   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
89997   return jresult;
89998 }
89999
90000
90001 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_FinishedSignal(void * jarg1) {
90002   void * jresult ;
90003   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
90004   Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *result = 0 ;
90005
90006   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
90007   {
90008     try {
90009       result = (Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *) &(arg1)->FinishedSignal();
90010     } catch (std::out_of_range& e) {
90011       {
90012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90013       };
90014     } catch (std::exception& e) {
90015       {
90016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90017       };
90018     } catch (Dali::DaliException e) {
90019       {
90020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90021       };
90022     } catch (...) {
90023       {
90024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90025       };
90026     }
90027   }
90028
90029   jresult = (void *)result;
90030   return jresult;
90031 }
90032
90033
90034 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageFactory(void * jarg1) {
90035   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
90036
90037   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
90038   {
90039     try {
90040       delete arg1;
90041     } catch (std::out_of_range& e) {
90042       {
90043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90044       };
90045     } catch (std::exception& e) {
90046       {
90047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90048       };
90049     } catch (Dali::DaliException e) {
90050       {
90051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90052       };
90053     } catch (...) {
90054       {
90055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90056       };
90057     }
90058   }
90059
90060 }
90061
90062
90063 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageFactory_GetNumberOfPages(void * jarg1) {
90064   unsigned int jresult ;
90065   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
90066   unsigned int result;
90067
90068   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
90069   {
90070     try {
90071       result = (unsigned int)(arg1)->GetNumberOfPages();
90072     } catch (std::out_of_range& e) {
90073       {
90074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90075       };
90076     } catch (std::exception& e) {
90077       {
90078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90079       };
90080     } catch (Dali::DaliException e) {
90081       {
90082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90083       };
90084     } catch (...) {
90085       {
90086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90087       };
90088     }
90089   }
90090
90091   jresult = result;
90092   return jresult;
90093 }
90094
90095
90096 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageFactory_NewPage(void * jarg1, unsigned int jarg2) {
90097   void * jresult ;
90098   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
90099   unsigned int arg2 ;
90100   Dali::Texture result;
90101
90102   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
90103   arg2 = (unsigned int)jarg2;
90104   {
90105     try {
90106       result = (arg1)->NewPage(arg2);
90107     } catch (std::out_of_range& e) {
90108       {
90109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90110       };
90111     } catch (std::exception& e) {
90112       {
90113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90114       };
90115     } catch (Dali::DaliException e) {
90116       {
90117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90118       };
90119     } catch (...) {
90120       {
90121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90122       };
90123     }
90124   }
90125
90126   jresult = new Dali::Texture((const Dali::Texture &)result);
90127   return jresult;
90128 }
90129
90130
90131 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_PAGE_SIZE_get() {
90132   int jresult ;
90133   int result;
90134
90135   result = (int)Dali::Toolkit::PageTurnView::Property::PAGE_SIZE;
90136   jresult = (int)result;
90137   return jresult;
90138 }
90139
90140
90141 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_CURRENT_PAGE_ID_get() {
90142   int jresult ;
90143   int result;
90144
90145   result = (int)Dali::Toolkit::PageTurnView::Property::CURRENT_PAGE_ID;
90146   jresult = (int)result;
90147   return jresult;
90148 }
90149
90150
90151 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_SPINE_SHADOW_get() {
90152   int jresult ;
90153   int result;
90154
90155   result = (int)Dali::Toolkit::PageTurnView::Property::SPINE_SHADOW;
90156   jresult = (int)result;
90157   return jresult;
90158 }
90159
90160
90161 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView_Property() {
90162   void * jresult ;
90163   Dali::Toolkit::PageTurnView::Property *result = 0 ;
90164
90165   {
90166     try {
90167       result = (Dali::Toolkit::PageTurnView::Property *)new Dali::Toolkit::PageTurnView::Property();
90168     } catch (std::out_of_range& e) {
90169       {
90170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90171       };
90172     } catch (std::exception& e) {
90173       {
90174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90175       };
90176     } catch (Dali::DaliException e) {
90177       {
90178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90179       };
90180     } catch (...) {
90181       {
90182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90183       };
90184     }
90185   }
90186
90187   jresult = (void *)result;
90188   return jresult;
90189 }
90190
90191
90192 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView_Property(void * jarg1) {
90193   Dali::Toolkit::PageTurnView::Property *arg1 = (Dali::Toolkit::PageTurnView::Property *) 0 ;
90194
90195   arg1 = (Dali::Toolkit::PageTurnView::Property *)jarg1;
90196   {
90197     try {
90198       delete arg1;
90199     } catch (std::out_of_range& e) {
90200       {
90201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90202       };
90203     } catch (std::exception& e) {
90204       {
90205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90206       };
90207     } catch (Dali::DaliException e) {
90208       {
90209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90210       };
90211     } catch (...) {
90212       {
90213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90214       };
90215     }
90216   }
90217
90218 }
90219
90220
90221 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_0() {
90222   void * jresult ;
90223   Dali::Toolkit::PageTurnView *result = 0 ;
90224
90225   {
90226     try {
90227       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView();
90228     } catch (std::out_of_range& e) {
90229       {
90230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90231       };
90232     } catch (std::exception& e) {
90233       {
90234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90235       };
90236     } catch (Dali::DaliException e) {
90237       {
90238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90239       };
90240     } catch (...) {
90241       {
90242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90243       };
90244     }
90245   }
90246
90247   jresult = (void *)result;
90248   return jresult;
90249 }
90250
90251
90252 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_1(void * jarg1) {
90253   void * jresult ;
90254   Dali::Toolkit::PageTurnView *arg1 = 0 ;
90255   Dali::Toolkit::PageTurnView *result = 0 ;
90256
90257   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90258   if (!arg1) {
90259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
90260     return 0;
90261   }
90262   {
90263     try {
90264       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView((Dali::Toolkit::PageTurnView const &)*arg1);
90265     } catch (std::out_of_range& e) {
90266       {
90267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90268       };
90269     } catch (std::exception& e) {
90270       {
90271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90272       };
90273     } catch (Dali::DaliException e) {
90274       {
90275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90276       };
90277     } catch (...) {
90278       {
90279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90280       };
90281     }
90282   }
90283
90284   jresult = (void *)result;
90285   return jresult;
90286 }
90287
90288
90289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_Assign(void * jarg1, void * jarg2) {
90290   void * jresult ;
90291   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90292   Dali::Toolkit::PageTurnView *arg2 = 0 ;
90293   Dali::Toolkit::PageTurnView *result = 0 ;
90294
90295   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90296   arg2 = (Dali::Toolkit::PageTurnView *)jarg2;
90297   if (!arg2) {
90298     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
90299     return 0;
90300   }
90301   {
90302     try {
90303       result = (Dali::Toolkit::PageTurnView *) &(arg1)->operator =((Dali::Toolkit::PageTurnView const &)*arg2);
90304     } catch (std::out_of_range& e) {
90305       {
90306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90307       };
90308     } catch (std::exception& e) {
90309       {
90310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90311       };
90312     } catch (Dali::DaliException e) {
90313       {
90314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90315       };
90316     } catch (...) {
90317       {
90318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90319       };
90320     }
90321   }
90322
90323   jresult = (void *)result;
90324   return jresult;
90325 }
90326
90327
90328 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView(void * jarg1) {
90329   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90330
90331   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90332   {
90333     try {
90334       delete arg1;
90335     } catch (std::out_of_range& e) {
90336       {
90337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90338       };
90339     } catch (std::exception& e) {
90340       {
90341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90342       };
90343     } catch (Dali::DaliException e) {
90344       {
90345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90346       };
90347     } catch (...) {
90348       {
90349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90350       };
90351     }
90352   }
90353
90354 }
90355
90356
90357 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_DownCast(void * jarg1) {
90358   void * jresult ;
90359   Dali::BaseHandle arg1 ;
90360   Dali::BaseHandle *argp1 ;
90361   Dali::Toolkit::PageTurnView result;
90362
90363   argp1 = (Dali::BaseHandle *)jarg1;
90364   if (!argp1) {
90365     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
90366     return 0;
90367   }
90368   arg1 = *argp1;
90369   {
90370     try {
90371       result = Dali::Toolkit::PageTurnView::DownCast(arg1);
90372     } catch (std::out_of_range& e) {
90373       {
90374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90375       };
90376     } catch (std::exception& e) {
90377       {
90378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90379       };
90380     } catch (Dali::DaliException e) {
90381       {
90382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90383       };
90384     } catch (...) {
90385       {
90386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90387       };
90388     }
90389   }
90390
90391   jresult = new Dali::Toolkit::PageTurnView((const Dali::Toolkit::PageTurnView &)result);
90392   return jresult;
90393 }
90394
90395
90396 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnStartedSignal(void * jarg1) {
90397   void * jresult ;
90398   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90399   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
90400
90401   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90402   {
90403     try {
90404       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnStartedSignal();
90405     } catch (std::out_of_range& e) {
90406       {
90407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90408       };
90409     } catch (std::exception& e) {
90410       {
90411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90412       };
90413     } catch (Dali::DaliException e) {
90414       {
90415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90416       };
90417     } catch (...) {
90418       {
90419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90420       };
90421     }
90422   }
90423
90424   jresult = (void *)result;
90425   return jresult;
90426 }
90427
90428
90429 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnFinishedSignal(void * jarg1) {
90430   void * jresult ;
90431   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90432   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
90433
90434   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90435   {
90436     try {
90437       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnFinishedSignal();
90438     } catch (std::out_of_range& e) {
90439       {
90440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90441       };
90442     } catch (std::exception& e) {
90443       {
90444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90445       };
90446     } catch (Dali::DaliException e) {
90447       {
90448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90449       };
90450     } catch (...) {
90451       {
90452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90453       };
90454     }
90455   }
90456
90457   jresult = (void *)result;
90458   return jresult;
90459 }
90460
90461
90462 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanStartedSignal(void * jarg1) {
90463   void * jresult ;
90464   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90465   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
90466
90467   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90468   {
90469     try {
90470       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanStartedSignal();
90471     } catch (std::out_of_range& e) {
90472       {
90473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90474       };
90475     } catch (std::exception& e) {
90476       {
90477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90478       };
90479     } catch (Dali::DaliException e) {
90480       {
90481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90482       };
90483     } catch (...) {
90484       {
90485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90486       };
90487     }
90488   }
90489
90490   jresult = (void *)result;
90491   return jresult;
90492 }
90493
90494
90495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanFinishedSignal(void * jarg1) {
90496   void * jresult ;
90497   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90498   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
90499
90500   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90501   {
90502     try {
90503       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanFinishedSignal();
90504     } catch (std::out_of_range& e) {
90505       {
90506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90507       };
90508     } catch (std::exception& e) {
90509       {
90510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90511       };
90512     } catch (Dali::DaliException e) {
90513       {
90514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90515       };
90516     } catch (...) {
90517       {
90518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90519       };
90520     }
90521   }
90522
90523   jresult = (void *)result;
90524   return jresult;
90525 }
90526
90527
90528 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_0() {
90529   void * jresult ;
90530   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
90531
90532   {
90533     try {
90534       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView();
90535     } catch (std::out_of_range& e) {
90536       {
90537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90538       };
90539     } catch (std::exception& e) {
90540       {
90541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90542       };
90543     } catch (Dali::DaliException e) {
90544       {
90545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90546       };
90547     } catch (...) {
90548       {
90549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90550       };
90551     }
90552   }
90553
90554   jresult = (void *)result;
90555   return jresult;
90556 }
90557
90558
90559 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_1(void * jarg1) {
90560   void * jresult ;
90561   Dali::Toolkit::PageTurnLandscapeView *arg1 = 0 ;
90562   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
90563
90564   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
90565   if (!arg1) {
90566     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
90567     return 0;
90568   }
90569   {
90570     try {
90571       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView((Dali::Toolkit::PageTurnLandscapeView const &)*arg1);
90572     } catch (std::out_of_range& e) {
90573       {
90574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90575       };
90576     } catch (std::exception& e) {
90577       {
90578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90579       };
90580     } catch (Dali::DaliException e) {
90581       {
90582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90583       };
90584     } catch (...) {
90585       {
90586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90587       };
90588     }
90589   }
90590
90591   jresult = (void *)result;
90592   return jresult;
90593 }
90594
90595
90596 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_Assign(void * jarg1, void * jarg2) {
90597   void * jresult ;
90598   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
90599   Dali::Toolkit::PageTurnLandscapeView *arg2 = 0 ;
90600   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
90601
90602   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
90603   arg2 = (Dali::Toolkit::PageTurnLandscapeView *)jarg2;
90604   if (!arg2) {
90605     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
90606     return 0;
90607   }
90608   {
90609     try {
90610       result = (Dali::Toolkit::PageTurnLandscapeView *) &(arg1)->operator =((Dali::Toolkit::PageTurnLandscapeView const &)*arg2);
90611     } catch (std::out_of_range& e) {
90612       {
90613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90614       };
90615     } catch (std::exception& e) {
90616       {
90617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90618       };
90619     } catch (Dali::DaliException e) {
90620       {
90621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90622       };
90623     } catch (...) {
90624       {
90625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90626       };
90627     }
90628   }
90629
90630   jresult = (void *)result;
90631   return jresult;
90632 }
90633
90634
90635 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnLandscapeView(void * jarg1) {
90636   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
90637
90638   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
90639   {
90640     try {
90641       delete arg1;
90642     } catch (std::out_of_range& e) {
90643       {
90644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90645       };
90646     } catch (std::exception& e) {
90647       {
90648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90649       };
90650     } catch (Dali::DaliException e) {
90651       {
90652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90653       };
90654     } catch (...) {
90655       {
90656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90657       };
90658     }
90659   }
90660
90661 }
90662
90663
90664 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_New(void * jarg1, void * jarg2) {
90665   void * jresult ;
90666   Dali::Toolkit::PageFactory *arg1 = 0 ;
90667   Dali::Vector2 *arg2 = 0 ;
90668   Dali::Toolkit::PageTurnLandscapeView result;
90669
90670   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
90671   if (!arg1) {
90672     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
90673     return 0;
90674   }
90675   arg2 = (Dali::Vector2 *)jarg2;
90676   if (!arg2) {
90677     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
90678     return 0;
90679   }
90680   {
90681     try {
90682       result = Dali::Toolkit::PageTurnLandscapeView::New(*arg1,(Dali::Vector2 const &)*arg2);
90683     } catch (std::out_of_range& e) {
90684       {
90685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90686       };
90687     } catch (std::exception& e) {
90688       {
90689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90690       };
90691     } catch (Dali::DaliException e) {
90692       {
90693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90694       };
90695     } catch (...) {
90696       {
90697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90698       };
90699     }
90700   }
90701
90702   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
90703   return jresult;
90704 }
90705
90706
90707 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_DownCast(void * jarg1) {
90708   void * jresult ;
90709   Dali::BaseHandle arg1 ;
90710   Dali::BaseHandle *argp1 ;
90711   Dali::Toolkit::PageTurnLandscapeView result;
90712
90713   argp1 = (Dali::BaseHandle *)jarg1;
90714   if (!argp1) {
90715     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
90716     return 0;
90717   }
90718   arg1 = *argp1;
90719   {
90720     try {
90721       result = Dali::Toolkit::PageTurnLandscapeView::DownCast(arg1);
90722     } catch (std::out_of_range& e) {
90723       {
90724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90725       };
90726     } catch (std::exception& e) {
90727       {
90728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90729       };
90730     } catch (Dali::DaliException e) {
90731       {
90732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90733       };
90734     } catch (...) {
90735       {
90736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90737       };
90738     }
90739   }
90740
90741   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
90742   return jresult;
90743 }
90744
90745
90746 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_0() {
90747   void * jresult ;
90748   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
90749
90750   {
90751     try {
90752       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView();
90753     } catch (std::out_of_range& e) {
90754       {
90755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90756       };
90757     } catch (std::exception& e) {
90758       {
90759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90760       };
90761     } catch (Dali::DaliException e) {
90762       {
90763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90764       };
90765     } catch (...) {
90766       {
90767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90768       };
90769     }
90770   }
90771
90772   jresult = (void *)result;
90773   return jresult;
90774 }
90775
90776
90777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_1(void * jarg1) {
90778   void * jresult ;
90779   Dali::Toolkit::PageTurnPortraitView *arg1 = 0 ;
90780   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
90781
90782   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
90783   if (!arg1) {
90784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
90785     return 0;
90786   }
90787   {
90788     try {
90789       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView((Dali::Toolkit::PageTurnPortraitView const &)*arg1);
90790     } catch (std::out_of_range& e) {
90791       {
90792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90793       };
90794     } catch (std::exception& e) {
90795       {
90796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90797       };
90798     } catch (Dali::DaliException e) {
90799       {
90800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90801       };
90802     } catch (...) {
90803       {
90804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90805       };
90806     }
90807   }
90808
90809   jresult = (void *)result;
90810   return jresult;
90811 }
90812
90813
90814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_Assign(void * jarg1, void * jarg2) {
90815   void * jresult ;
90816   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
90817   Dali::Toolkit::PageTurnPortraitView *arg2 = 0 ;
90818   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
90819
90820   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
90821   arg2 = (Dali::Toolkit::PageTurnPortraitView *)jarg2;
90822   if (!arg2) {
90823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
90824     return 0;
90825   }
90826   {
90827     try {
90828       result = (Dali::Toolkit::PageTurnPortraitView *) &(arg1)->operator =((Dali::Toolkit::PageTurnPortraitView const &)*arg2);
90829     } catch (std::out_of_range& e) {
90830       {
90831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90832       };
90833     } catch (std::exception& e) {
90834       {
90835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90836       };
90837     } catch (Dali::DaliException e) {
90838       {
90839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90840       };
90841     } catch (...) {
90842       {
90843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90844       };
90845     }
90846   }
90847
90848   jresult = (void *)result;
90849   return jresult;
90850 }
90851
90852
90853 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnPortraitView(void * jarg1) {
90854   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
90855
90856   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
90857   {
90858     try {
90859       delete arg1;
90860     } catch (std::out_of_range& e) {
90861       {
90862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90863       };
90864     } catch (std::exception& e) {
90865       {
90866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90867       };
90868     } catch (Dali::DaliException e) {
90869       {
90870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90871       };
90872     } catch (...) {
90873       {
90874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90875       };
90876     }
90877   }
90878
90879 }
90880
90881
90882 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_New(void * jarg1, void * jarg2) {
90883   void * jresult ;
90884   Dali::Toolkit::PageFactory *arg1 = 0 ;
90885   Dali::Vector2 *arg2 = 0 ;
90886   Dali::Toolkit::PageTurnPortraitView result;
90887
90888   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
90889   if (!arg1) {
90890     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
90891     return 0;
90892   }
90893   arg2 = (Dali::Vector2 *)jarg2;
90894   if (!arg2) {
90895     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
90896     return 0;
90897   }
90898   {
90899     try {
90900       result = Dali::Toolkit::PageTurnPortraitView::New(*arg1,(Dali::Vector2 const &)*arg2);
90901     } catch (std::out_of_range& e) {
90902       {
90903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90904       };
90905     } catch (std::exception& e) {
90906       {
90907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90908       };
90909     } catch (Dali::DaliException e) {
90910       {
90911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90912       };
90913     } catch (...) {
90914       {
90915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90916       };
90917     }
90918   }
90919
90920   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
90921   return jresult;
90922 }
90923
90924
90925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_DownCast(void * jarg1) {
90926   void * jresult ;
90927   Dali::BaseHandle arg1 ;
90928   Dali::BaseHandle *argp1 ;
90929   Dali::Toolkit::PageTurnPortraitView result;
90930
90931   argp1 = (Dali::BaseHandle *)jarg1;
90932   if (!argp1) {
90933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
90934     return 0;
90935   }
90936   arg1 = *argp1;
90937   {
90938     try {
90939       result = Dali::Toolkit::PageTurnPortraitView::DownCast(arg1);
90940     } catch (std::out_of_range& e) {
90941       {
90942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90943       };
90944     } catch (std::exception& e) {
90945       {
90946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90947       };
90948     } catch (Dali::DaliException e) {
90949       {
90950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90951       };
90952     } catch (...) {
90953       {
90954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90955       };
90956     }
90957   }
90958
90959   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
90960   return jresult;
90961 }
90962
90963
90964 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_STATE_VISUALS_get() {
90965   int jresult ;
90966   int result;
90967
90968   result = (int)Dali::Toolkit::ToggleButton::Property::STATE_VISUALS;
90969   jresult = (int)result;
90970   return jresult;
90971 }
90972
90973
90974 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_TOOLTIPS_get() {
90975   int jresult ;
90976   int result;
90977
90978   result = (int)Dali::Toolkit::ToggleButton::Property::TOOLTIPS;
90979   jresult = (int)result;
90980   return jresult;
90981 }
90982
90983
90984 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_CURRENT_STATE_INDEX_get() {
90985   int jresult ;
90986   int result;
90987
90988   result = (int)Dali::Toolkit::ToggleButton::Property::CURRENT_STATE_INDEX;
90989   jresult = (int)result;
90990   return jresult;
90991 }
90992
90993
90994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton_Property() {
90995   void * jresult ;
90996   Dali::Toolkit::ToggleButton::Property *result = 0 ;
90997
90998   {
90999     try {
91000       result = (Dali::Toolkit::ToggleButton::Property *)new Dali::Toolkit::ToggleButton::Property();
91001     } catch (std::out_of_range& e) {
91002       {
91003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91004       };
91005     } catch (std::exception& e) {
91006       {
91007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91008       };
91009     } catch (Dali::DaliException e) {
91010       {
91011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91012       };
91013     } catch (...) {
91014       {
91015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91016       };
91017     }
91018   }
91019
91020   jresult = (void *)result;
91021   return jresult;
91022 }
91023
91024
91025 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton_Property(void * jarg1) {
91026   Dali::Toolkit::ToggleButton::Property *arg1 = (Dali::Toolkit::ToggleButton::Property *) 0 ;
91027
91028   arg1 = (Dali::Toolkit::ToggleButton::Property *)jarg1;
91029   {
91030     try {
91031       delete arg1;
91032     } catch (std::out_of_range& e) {
91033       {
91034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91035       };
91036     } catch (std::exception& e) {
91037       {
91038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91039       };
91040     } catch (Dali::DaliException e) {
91041       {
91042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91043       };
91044     } catch (...) {
91045       {
91046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91047       };
91048     }
91049   }
91050
91051 }
91052
91053
91054 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_0() {
91055   void * jresult ;
91056   Dali::Toolkit::ToggleButton *result = 0 ;
91057
91058   {
91059     try {
91060       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton();
91061     } catch (std::out_of_range& e) {
91062       {
91063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91064       };
91065     } catch (std::exception& e) {
91066       {
91067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91068       };
91069     } catch (Dali::DaliException e) {
91070       {
91071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91072       };
91073     } catch (...) {
91074       {
91075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91076       };
91077     }
91078   }
91079
91080   jresult = (void *)result;
91081   return jresult;
91082 }
91083
91084
91085 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_1(void * jarg1) {
91086   void * jresult ;
91087   Dali::Toolkit::ToggleButton *arg1 = 0 ;
91088   Dali::Toolkit::ToggleButton *result = 0 ;
91089
91090   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
91091   if (!arg1) {
91092     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
91093     return 0;
91094   }
91095   {
91096     try {
91097       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton((Dali::Toolkit::ToggleButton const &)*arg1);
91098     } catch (std::out_of_range& e) {
91099       {
91100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91101       };
91102     } catch (std::exception& e) {
91103       {
91104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91105       };
91106     } catch (Dali::DaliException e) {
91107       {
91108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91109       };
91110     } catch (...) {
91111       {
91112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91113       };
91114     }
91115   }
91116
91117   jresult = (void *)result;
91118   return jresult;
91119 }
91120
91121
91122 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_Assign(void * jarg1, void * jarg2) {
91123   void * jresult ;
91124   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
91125   Dali::Toolkit::ToggleButton *arg2 = 0 ;
91126   Dali::Toolkit::ToggleButton *result = 0 ;
91127
91128   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
91129   arg2 = (Dali::Toolkit::ToggleButton *)jarg2;
91130   if (!arg2) {
91131     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
91132     return 0;
91133   }
91134   {
91135     try {
91136       result = (Dali::Toolkit::ToggleButton *) &(arg1)->operator =((Dali::Toolkit::ToggleButton const &)*arg2);
91137     } catch (std::out_of_range& e) {
91138       {
91139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91140       };
91141     } catch (std::exception& e) {
91142       {
91143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91144       };
91145     } catch (Dali::DaliException e) {
91146       {
91147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91148       };
91149     } catch (...) {
91150       {
91151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91152       };
91153     }
91154   }
91155
91156   jresult = (void *)result;
91157   return jresult;
91158 }
91159
91160
91161 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton(void * jarg1) {
91162   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
91163
91164   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
91165   {
91166     try {
91167       delete arg1;
91168     } catch (std::out_of_range& e) {
91169       {
91170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91171       };
91172     } catch (std::exception& e) {
91173       {
91174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91175       };
91176     } catch (Dali::DaliException e) {
91177       {
91178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91179       };
91180     } catch (...) {
91181       {
91182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91183       };
91184     }
91185   }
91186
91187 }
91188
91189
91190 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_New() {
91191   void * jresult ;
91192   Dali::Toolkit::ToggleButton result;
91193
91194   {
91195     try {
91196       result = Dali::Toolkit::ToggleButton::New();
91197     } catch (std::out_of_range& e) {
91198       {
91199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91200       };
91201     } catch (std::exception& e) {
91202       {
91203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91204       };
91205     } catch (Dali::DaliException e) {
91206       {
91207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91208       };
91209     } catch (...) {
91210       {
91211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91212       };
91213     }
91214   }
91215
91216   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
91217   return jresult;
91218 }
91219
91220
91221 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_DownCast(void * jarg1) {
91222   void * jresult ;
91223   Dali::BaseHandle arg1 ;
91224   Dali::BaseHandle *argp1 ;
91225   Dali::Toolkit::ToggleButton result;
91226
91227   argp1 = (Dali::BaseHandle *)jarg1;
91228   if (!argp1) {
91229     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
91230     return 0;
91231   }
91232   arg1 = *argp1;
91233   {
91234     try {
91235       result = Dali::Toolkit::ToggleButton::DownCast(arg1);
91236     } catch (std::out_of_range& e) {
91237       {
91238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91239       };
91240     } catch (std::exception& e) {
91241       {
91242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91243       };
91244     } catch (Dali::DaliException e) {
91245       {
91246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91247       };
91248     } catch (...) {
91249       {
91250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91251       };
91252     }
91253   }
91254
91255   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
91256   return jresult;
91257 }
91258
91259
91260 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_0() {
91261   void * jresult ;
91262   Dali::Toolkit::Visual::Base *result = 0 ;
91263
91264   {
91265     try {
91266       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base();
91267     } catch (std::out_of_range& e) {
91268       {
91269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91270       };
91271     } catch (std::exception& e) {
91272       {
91273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91274       };
91275     } catch (Dali::DaliException e) {
91276       {
91277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91278       };
91279     } catch (...) {
91280       {
91281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91282       };
91283     }
91284   }
91285
91286   jresult = (void *)result;
91287   return jresult;
91288 }
91289
91290
91291 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualBase(void * jarg1) {
91292   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91293
91294   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91295   {
91296     try {
91297       delete arg1;
91298     } catch (std::out_of_range& e) {
91299       {
91300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91301       };
91302     } catch (std::exception& e) {
91303       {
91304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91305       };
91306     } catch (Dali::DaliException e) {
91307       {
91308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91309       };
91310     } catch (...) {
91311       {
91312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91313       };
91314     }
91315   }
91316
91317 }
91318
91319
91320 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_1(void * jarg1) {
91321   void * jresult ;
91322   Dali::Toolkit::Visual::Base *arg1 = 0 ;
91323   Dali::Toolkit::Visual::Base *result = 0 ;
91324
91325   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91326   if (!arg1) {
91327     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
91328     return 0;
91329   }
91330   {
91331     try {
91332       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base((Dali::Toolkit::Visual::Base const &)*arg1);
91333     } catch (std::out_of_range& e) {
91334       {
91335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91336       };
91337     } catch (std::exception& e) {
91338       {
91339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91340       };
91341     } catch (Dali::DaliException e) {
91342       {
91343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91344       };
91345     } catch (...) {
91346       {
91347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91348       };
91349     }
91350   }
91351
91352   jresult = (void *)result;
91353   return jresult;
91354 }
91355
91356
91357 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualBase_Assign(void * jarg1, void * jarg2) {
91358   void * jresult ;
91359   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91360   Dali::Toolkit::Visual::Base *arg2 = 0 ;
91361   Dali::Toolkit::Visual::Base *result = 0 ;
91362
91363   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91364   arg2 = (Dali::Toolkit::Visual::Base *)jarg2;
91365   if (!arg2) {
91366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
91367     return 0;
91368   }
91369   {
91370     try {
91371       result = (Dali::Toolkit::Visual::Base *) &(arg1)->operator =((Dali::Toolkit::Visual::Base const &)*arg2);
91372     } catch (std::out_of_range& e) {
91373       {
91374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91375       };
91376     } catch (std::exception& e) {
91377       {
91378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91379       };
91380     } catch (Dali::DaliException e) {
91381       {
91382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91383       };
91384     } catch (...) {
91385       {
91386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91387       };
91388     }
91389   }
91390
91391   jresult = (void *)result;
91392   return jresult;
91393 }
91394
91395
91396 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetName(void * jarg1, char * jarg2) {
91397   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91398   std::string *arg2 = 0 ;
91399
91400   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91401   if (!jarg2) {
91402     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91403     return ;
91404   }
91405   std::string arg2_str(jarg2);
91406   arg2 = &arg2_str;
91407   {
91408     try {
91409       (arg1)->SetName((std::string const &)*arg2);
91410     } catch (std::out_of_range& e) {
91411       {
91412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91413       };
91414     } catch (std::exception& e) {
91415       {
91416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91417       };
91418     } catch (Dali::DaliException e) {
91419       {
91420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91421       };
91422     } catch (...) {
91423       {
91424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91425       };
91426     }
91427   }
91428
91429
91430   //argout typemap for const std::string&
91431
91432 }
91433
91434
91435 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_VisualBase_GetName(void * jarg1) {
91436   char * jresult ;
91437   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91438   std::string *result = 0 ;
91439
91440   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91441   {
91442     try {
91443       result = (std::string *) &(arg1)->GetName();
91444     } catch (std::out_of_range& e) {
91445       {
91446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91447       };
91448     } catch (std::exception& e) {
91449       {
91450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91451       };
91452     } catch (Dali::DaliException e) {
91453       {
91454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91455       };
91456     } catch (...) {
91457       {
91458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91459       };
91460     }
91461   }
91462
91463   jresult = SWIG_csharp_string_callback(result->c_str());
91464   return jresult;
91465 }
91466
91467
91468 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetTransformAndSize(void * jarg1, void * jarg2, void * jarg3) {
91469   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91470   Dali::Property::Map *arg2 = 0 ;
91471   Dali::Size arg3 ;
91472   Dali::Size *argp3 ;
91473
91474   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91475   arg2 = (Dali::Property::Map *)jarg2;
91476   if (!arg2) {
91477     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
91478     return ;
91479   }
91480   argp3 = (Dali::Size *)jarg3;
91481   if (!argp3) {
91482     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
91483     return ;
91484   }
91485   arg3 = *argp3;
91486   {
91487     try {
91488       (arg1)->SetTransformAndSize((Dali::Property::Map const &)*arg2,arg3);
91489     } catch (std::out_of_range& e) {
91490       {
91491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91492       };
91493     } catch (std::exception& e) {
91494       {
91495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91496       };
91497     } catch (Dali::DaliException e) {
91498       {
91499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91500       };
91501     } catch (...) {
91502       {
91503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91504       };
91505     }
91506   }
91507
91508 }
91509
91510
91511 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetHeightForWidth(void * jarg1, float jarg2) {
91512   float jresult ;
91513   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91514   float arg2 ;
91515   float result;
91516
91517   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91518   arg2 = (float)jarg2;
91519   {
91520     try {
91521       result = (float)(arg1)->GetHeightForWidth(arg2);
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 = result;
91542   return jresult;
91543 }
91544
91545
91546 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetWidthForHeight(void * jarg1, float jarg2) {
91547   float jresult ;
91548   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91549   float arg2 ;
91550   float result;
91551
91552   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91553   arg2 = (float)jarg2;
91554   {
91555     try {
91556       result = (float)(arg1)->GetWidthForHeight(arg2);
91557     } catch (std::out_of_range& e) {
91558       {
91559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91560       };
91561     } catch (std::exception& e) {
91562       {
91563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91564       };
91565     } catch (Dali::DaliException e) {
91566       {
91567         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91568       };
91569     } catch (...) {
91570       {
91571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91572       };
91573     }
91574   }
91575
91576   jresult = result;
91577   return jresult;
91578 }
91579
91580
91581 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_GetNaturalSize(void * jarg1, void * jarg2) {
91582   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91583   Dali::Vector2 *arg2 = 0 ;
91584
91585   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91586   arg2 = (Dali::Vector2 *)jarg2;
91587   if (!arg2) {
91588     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
91589     return ;
91590   }
91591   {
91592     try {
91593       (arg1)->GetNaturalSize(*arg2);
91594     } catch (std::out_of_range& e) {
91595       {
91596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91597       };
91598     } catch (std::exception& e) {
91599       {
91600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91601       };
91602     } catch (Dali::DaliException e) {
91603       {
91604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91605       };
91606     } catch (...) {
91607       {
91608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91609       };
91610     }
91611   }
91612
91613 }
91614
91615
91616 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetDepthIndex(void * jarg1, int jarg2) {
91617   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91618   float arg2 ;
91619
91620   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91621   arg2 = (int)jarg2;
91622   {
91623     try {
91624       (arg1)->SetDepthIndex(arg2);
91625     } catch (std::out_of_range& e) {
91626       {
91627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91628       };
91629     } catch (std::exception& e) {
91630       {
91631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91632       };
91633     } catch (Dali::DaliException e) {
91634       {
91635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91636       };
91637     } catch (...) {
91638       {
91639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91640       };
91641     }
91642   }
91643
91644 }
91645
91646
91647 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VisualBase_GetDepthIndex(void * jarg1) {
91648   int jresult ;
91649   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91650   int result;
91651
91652   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91653   {
91654     try {
91655       result = (float)((Dali::Toolkit::Visual::Base const *)arg1)->GetDepthIndex();
91656     } catch (std::out_of_range& e) {
91657       {
91658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91659       };
91660     } catch (std::exception& e) {
91661       {
91662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91663       };
91664     } catch (Dali::DaliException e) {
91665       {
91666         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91667       };
91668     } catch (...) {
91669       {
91670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91671       };
91672     }
91673   }
91674
91675   jresult = result;
91676   return jresult;
91677 }
91678
91679
91680 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_CreatePropertyMap(void * jarg1, void * jarg2) {
91681   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91682   Dali::Property::Map *arg2 = 0 ;
91683
91684   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91685   arg2 = (Dali::Property::Map *)jarg2;
91686   if (!arg2) {
91687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
91688     return ;
91689   }
91690   {
91691     try {
91692       ((Dali::Toolkit::Visual::Base const *)arg1)->CreatePropertyMap(*arg2);
91693     } catch (std::out_of_range& e) {
91694       {
91695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91696       };
91697     } catch (std::exception& e) {
91698       {
91699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91700       };
91701     } catch (Dali::DaliException e) {
91702       {
91703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91704       };
91705     } catch (...) {
91706       {
91707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91708       };
91709     }
91710   }
91711
91712 }
91713
91714
91715 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_2(void * jarg1) {
91716   void * jresult ;
91717   Dali::Toolkit::Internal::Visual::Base *arg1 = (Dali::Toolkit::Internal::Visual::Base *) 0 ;
91718   Dali::Toolkit::Visual::Base *result = 0 ;
91719
91720   arg1 = (Dali::Toolkit::Internal::Visual::Base *)jarg1;
91721   {
91722     try {
91723       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base(arg1);
91724     } catch (std::out_of_range& e) {
91725       {
91726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91727       };
91728     } catch (std::exception& e) {
91729       {
91730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91731       };
91732     } catch (Dali::DaliException e) {
91733       {
91734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91735       };
91736     } catch (...) {
91737       {
91738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91739       };
91740     }
91741   }
91742
91743   jresult = (void *)result;
91744   return jresult;
91745 }
91746
91747
91748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Get() {
91749   void * jresult ;
91750   Dali::Toolkit::VisualFactory result;
91751
91752   {
91753     try {
91754       result = Dali::Toolkit::VisualFactory::Get();
91755     } catch (std::out_of_range& e) {
91756       {
91757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91758       };
91759     } catch (std::exception& e) {
91760       {
91761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91762       };
91763     } catch (Dali::DaliException e) {
91764       {
91765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91766       };
91767     } catch (...) {
91768       {
91769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91770       };
91771     }
91772   }
91773
91774   jresult = new Dali::Toolkit::VisualFactory((const Dali::Toolkit::VisualFactory &)result);
91775   return jresult;
91776 }
91777
91778
91779 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_0() {
91780   void * jresult ;
91781   Dali::Toolkit::VisualFactory *result = 0 ;
91782
91783   {
91784     try {
91785       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory();
91786     } catch (std::out_of_range& e) {
91787       {
91788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91789       };
91790     } catch (std::exception& e) {
91791       {
91792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91793       };
91794     } catch (Dali::DaliException e) {
91795       {
91796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91797       };
91798     } catch (...) {
91799       {
91800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91801       };
91802     }
91803   }
91804
91805   jresult = (void *)result;
91806   return jresult;
91807 }
91808
91809
91810 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualFactory(void * jarg1) {
91811   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91812
91813   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91814   {
91815     try {
91816       delete arg1;
91817     } catch (std::out_of_range& e) {
91818       {
91819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91820       };
91821     } catch (std::exception& e) {
91822       {
91823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91824       };
91825     } catch (Dali::DaliException e) {
91826       {
91827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91828       };
91829     } catch (...) {
91830       {
91831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91832       };
91833     }
91834   }
91835
91836 }
91837
91838
91839 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_1(void * jarg1) {
91840   void * jresult ;
91841   Dali::Toolkit::VisualFactory *arg1 = 0 ;
91842   Dali::Toolkit::VisualFactory *result = 0 ;
91843
91844   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91845   if (!arg1) {
91846     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
91847     return 0;
91848   }
91849   {
91850     try {
91851       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory((Dali::Toolkit::VisualFactory const &)*arg1);
91852     } catch (std::out_of_range& e) {
91853       {
91854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91855       };
91856     } catch (std::exception& e) {
91857       {
91858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91859       };
91860     } catch (Dali::DaliException e) {
91861       {
91862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91863       };
91864     } catch (...) {
91865       {
91866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91867       };
91868     }
91869   }
91870
91871   jresult = (void *)result;
91872   return jresult;
91873 }
91874
91875
91876 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Assign(void * jarg1, void * jarg2) {
91877   void * jresult ;
91878   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91879   Dali::Toolkit::VisualFactory *arg2 = 0 ;
91880   Dali::Toolkit::VisualFactory *result = 0 ;
91881
91882   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91883   arg2 = (Dali::Toolkit::VisualFactory *)jarg2;
91884   if (!arg2) {
91885     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
91886     return 0;
91887   }
91888   {
91889     try {
91890       result = (Dali::Toolkit::VisualFactory *) &(arg1)->operator =((Dali::Toolkit::VisualFactory const &)*arg2);
91891     } catch (std::out_of_range& e) {
91892       {
91893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91894       };
91895     } catch (std::exception& e) {
91896       {
91897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91898       };
91899     } catch (Dali::DaliException e) {
91900       {
91901         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91902       };
91903     } catch (...) {
91904       {
91905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91906       };
91907     }
91908   }
91909
91910   jresult = (void *)result;
91911   return jresult;
91912 }
91913
91914
91915 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_0(void * jarg1, void * jarg2) {
91916   void * jresult ;
91917   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91918   Dali::Property::Map *arg2 = 0 ;
91919   Dali::Toolkit::Visual::Base result;
91920
91921   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91922   arg2 = (Dali::Property::Map *)jarg2;
91923   if (!arg2) {
91924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
91925     return 0;
91926   }
91927   {
91928     try {
91929       result = (arg1)->CreateVisual((Dali::Property::Map const &)*arg2);
91930     } catch (std::out_of_range& e) {
91931       {
91932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91933       };
91934     } catch (std::exception& e) {
91935       {
91936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91937       };
91938     } catch (Dali::DaliException e) {
91939       {
91940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91941       };
91942     } catch (...) {
91943       {
91944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91945       };
91946     }
91947   }
91948
91949   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
91950   return jresult;
91951 }
91952
91953
91954 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_1(void * jarg1, void * jarg2) {
91955   void * jresult ;
91956   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91957   Dali::Image *arg2 = 0 ;
91958   Dali::Toolkit::Visual::Base result;
91959
91960   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91961   arg2 = (Dali::Image *)jarg2;
91962   if (!arg2) {
91963     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
91964     return 0;
91965   }
91966   {
91967     try {
91968       result = (arg1)->CreateVisual((Dali::Image const &)*arg2);
91969     } catch (std::out_of_range& e) {
91970       {
91971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91972       };
91973     } catch (std::exception& e) {
91974       {
91975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91976       };
91977     } catch (Dali::DaliException e) {
91978       {
91979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91980       };
91981     } catch (...) {
91982       {
91983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91984       };
91985     }
91986   }
91987
91988   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
91989   return jresult;
91990 }
91991
91992
91993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
91994   void * jresult ;
91995   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91996   std::string *arg2 = 0 ;
91997   Dali::ImageDimensions arg3 ;
91998   Dali::ImageDimensions *argp3 ;
91999   Dali::Toolkit::Visual::Base result;
92000
92001   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
92002   if (!jarg2) {
92003     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92004     return 0;
92005   }
92006   std::string arg2_str(jarg2);
92007   arg2 = &arg2_str;
92008   argp3 = (Dali::ImageDimensions *)jarg3;
92009   if (!argp3) {
92010     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
92011     return 0;
92012   }
92013   arg3 = *argp3;
92014   {
92015     try {
92016       result = (arg1)->CreateVisual((std::string const &)*arg2,arg3);
92017     } catch (std::out_of_range& e) {
92018       {
92019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92020       };
92021     } catch (std::exception& e) {
92022       {
92023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92024       };
92025     } catch (Dali::DaliException e) {
92026       {
92027         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92028       };
92029     } catch (...) {
92030       {
92031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92032       };
92033     }
92034   }
92035
92036   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
92037
92038   //argout typemap for const std::string&
92039
92040   return jresult;
92041 }
92042
92043
92044 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_0() {
92045   void * jresult ;
92046   Dali::Toolkit::AsyncImageLoader *result = 0 ;
92047
92048   {
92049     try {
92050       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader();
92051     } catch (std::out_of_range& e) {
92052       {
92053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92054       };
92055     } catch (std::exception& e) {
92056       {
92057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92058       };
92059     } catch (Dali::DaliException e) {
92060       {
92061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92062       };
92063     } catch (...) {
92064       {
92065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92066       };
92067     }
92068   }
92069
92070   jresult = (void *)result;
92071   return jresult;
92072 }
92073
92074
92075 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AsyncImageLoader(void * jarg1) {
92076   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92077
92078   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92079   {
92080     try {
92081       delete arg1;
92082     } catch (std::out_of_range& e) {
92083       {
92084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92085       };
92086     } catch (std::exception& e) {
92087       {
92088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92089       };
92090     } catch (Dali::DaliException e) {
92091       {
92092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92093       };
92094     } catch (...) {
92095       {
92096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92097       };
92098     }
92099   }
92100
92101 }
92102
92103
92104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_1(void * jarg1) {
92105   void * jresult ;
92106   Dali::Toolkit::AsyncImageLoader *arg1 = 0 ;
92107   Dali::Toolkit::AsyncImageLoader *result = 0 ;
92108
92109   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92110   if (!arg1) {
92111     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
92112     return 0;
92113   }
92114   {
92115     try {
92116       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader((Dali::Toolkit::AsyncImageLoader const &)*arg1);
92117     } catch (std::out_of_range& e) {
92118       {
92119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92120       };
92121     } catch (std::exception& e) {
92122       {
92123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92124       };
92125     } catch (Dali::DaliException e) {
92126       {
92127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92128       };
92129     } catch (...) {
92130       {
92131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92132       };
92133     }
92134   }
92135
92136   jresult = (void *)result;
92137   return jresult;
92138 }
92139
92140
92141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Assign(void * jarg1, void * jarg2) {
92142   void * jresult ;
92143   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92144   Dali::Toolkit::AsyncImageLoader *arg2 = 0 ;
92145   Dali::Toolkit::AsyncImageLoader *result = 0 ;
92146
92147   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92148   arg2 = (Dali::Toolkit::AsyncImageLoader *)jarg2;
92149   if (!arg2) {
92150     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
92151     return 0;
92152   }
92153   {
92154     try {
92155       result = (Dali::Toolkit::AsyncImageLoader *) &(arg1)->operator =((Dali::Toolkit::AsyncImageLoader const &)*arg2);
92156     } catch (std::out_of_range& e) {
92157       {
92158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92159       };
92160     } catch (std::exception& e) {
92161       {
92162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92163       };
92164     } catch (Dali::DaliException e) {
92165       {
92166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92167       };
92168     } catch (...) {
92169       {
92170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92171       };
92172     }
92173   }
92174
92175   jresult = (void *)result;
92176   return jresult;
92177 }
92178
92179
92180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_New() {
92181   void * jresult ;
92182   Dali::Toolkit::AsyncImageLoader result;
92183
92184   {
92185     try {
92186       result = Dali::Toolkit::AsyncImageLoader::New();
92187     } catch (std::out_of_range& e) {
92188       {
92189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92190       };
92191     } catch (std::exception& e) {
92192       {
92193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92194       };
92195     } catch (Dali::DaliException e) {
92196       {
92197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92198       };
92199     } catch (...) {
92200       {
92201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92202       };
92203     }
92204   }
92205
92206   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
92207   return jresult;
92208 }
92209
92210
92211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_DownCast(void * jarg1) {
92212   void * jresult ;
92213   Dali::BaseHandle arg1 ;
92214   Dali::BaseHandle *argp1 ;
92215   Dali::Toolkit::AsyncImageLoader result;
92216
92217   argp1 = (Dali::BaseHandle *)jarg1;
92218   if (!argp1) {
92219     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
92220     return 0;
92221   }
92222   arg1 = *argp1;
92223   {
92224     try {
92225       result = Dali::Toolkit::AsyncImageLoader::DownCast(arg1);
92226     } catch (std::out_of_range& e) {
92227       {
92228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92229       };
92230     } catch (std::exception& e) {
92231       {
92232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92233       };
92234     } catch (Dali::DaliException e) {
92235       {
92236         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92237       };
92238     } catch (...) {
92239       {
92240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92241       };
92242     }
92243   }
92244
92245   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
92246   return jresult;
92247 }
92248
92249
92250 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_0(void * jarg1, char * jarg2) {
92251   unsigned int jresult ;
92252   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92253   std::string *arg2 = 0 ;
92254   uint32_t result;
92255
92256   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92257   if (!jarg2) {
92258     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92259     return 0;
92260   }
92261   std::string arg2_str(jarg2);
92262   arg2 = &arg2_str;
92263   {
92264     try {
92265       result = (arg1)->Load((std::string const &)*arg2);
92266     } catch (std::out_of_range& e) {
92267       {
92268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92269       };
92270     } catch (std::exception& e) {
92271       {
92272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92273       };
92274     } catch (Dali::DaliException e) {
92275       {
92276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92277       };
92278     } catch (...) {
92279       {
92280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92281       };
92282     }
92283   }
92284
92285   jresult = result;
92286
92287   //argout typemap for const std::string&
92288
92289   return jresult;
92290 }
92291
92292
92293 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
92294   unsigned int jresult ;
92295   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92296   std::string *arg2 = 0 ;
92297   Dali::ImageDimensions arg3 ;
92298   Dali::ImageDimensions *argp3 ;
92299   uint32_t result;
92300
92301   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92302   if (!jarg2) {
92303     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92304     return 0;
92305   }
92306   std::string arg2_str(jarg2);
92307   arg2 = &arg2_str;
92308   argp3 = (Dali::ImageDimensions *)jarg3;
92309   if (!argp3) {
92310     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
92311     return 0;
92312   }
92313   arg3 = *argp3;
92314   {
92315     try {
92316       result = (arg1)->Load((std::string const &)*arg2,arg3);
92317     } catch (std::out_of_range& e) {
92318       {
92319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92320       };
92321     } catch (std::exception& e) {
92322       {
92323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92324       };
92325     } catch (Dali::DaliException e) {
92326       {
92327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92328       };
92329     } catch (...) {
92330       {
92331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92332       };
92333     }
92334   }
92335
92336   jresult = result;
92337
92338   //argout typemap for const std::string&
92339
92340   return jresult;
92341 }
92342
92343
92344 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_2(void * jarg1, char * jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
92345   unsigned int jresult ;
92346   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92347   std::string *arg2 = 0 ;
92348   Dali::ImageDimensions arg3 ;
92349   Dali::FittingMode::Type arg4 ;
92350   Dali::SamplingMode::Type arg5 ;
92351   bool arg6 ;
92352   Dali::ImageDimensions *argp3 ;
92353   uint32_t result;
92354
92355   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92356   if (!jarg2) {
92357     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92358     return 0;
92359   }
92360   std::string arg2_str(jarg2);
92361   arg2 = &arg2_str;
92362   argp3 = (Dali::ImageDimensions *)jarg3;
92363   if (!argp3) {
92364     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
92365     return 0;
92366   }
92367   arg3 = *argp3;
92368   arg4 = (Dali::FittingMode::Type)jarg4;
92369   arg5 = (Dali::SamplingMode::Type)jarg5;
92370   arg6 = jarg6 ? true : false;
92371   {
92372     try {
92373       result = (arg1)->Load((std::string const &)*arg2,arg3,arg4,arg5,arg6);
92374     } catch (std::out_of_range& e) {
92375       {
92376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92377       };
92378     } catch (std::exception& e) {
92379       {
92380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92381       };
92382     } catch (Dali::DaliException e) {
92383       {
92384         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92385       };
92386     } catch (...) {
92387       {
92388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92389       };
92390     }
92391   }
92392
92393   jresult = result;
92394
92395   //argout typemap for const std::string&
92396
92397   return jresult;
92398 }
92399
92400
92401 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Cancel(void * jarg1, unsigned int jarg2) {
92402   unsigned int jresult ;
92403   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92404   uint32_t arg2 ;
92405   bool result;
92406
92407   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92408   arg2 = (uint32_t)jarg2;
92409   {
92410     try {
92411       result = (bool)(arg1)->Cancel(arg2);
92412     } catch (std::out_of_range& e) {
92413       {
92414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92415       };
92416     } catch (std::exception& e) {
92417       {
92418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92419       };
92420     } catch (Dali::DaliException e) {
92421       {
92422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92423       };
92424     } catch (...) {
92425       {
92426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92427       };
92428     }
92429   }
92430
92431   jresult = result;
92432   return jresult;
92433 }
92434
92435
92436 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AsyncImageLoader_CancelAll(void * jarg1) {
92437   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92438
92439   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92440   {
92441     try {
92442       (arg1)->CancelAll();
92443     } catch (std::out_of_range& e) {
92444       {
92445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92446       };
92447     } catch (std::exception& e) {
92448       {
92449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92450       };
92451     } catch (Dali::DaliException e) {
92452       {
92453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92454       };
92455     } catch (...) {
92456       {
92457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92458       };
92459     }
92460   }
92461
92462 }
92463
92464
92465 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_ImageLoadedSignal(void * jarg1) {
92466   void * jresult ;
92467   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92468   Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *result = 0 ;
92469
92470   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92471   {
92472     try {
92473       result = (Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *) &(arg1)->ImageLoadedSignal();
92474     } catch (std::out_of_range& e) {
92475       {
92476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92477       };
92478     } catch (std::exception& e) {
92479       {
92480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92481       };
92482     } catch (Dali::DaliException e) {
92483       {
92484         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92485       };
92486     } catch (...) {
92487       {
92488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92489       };
92490     }
92491   }
92492
92493   jresult = (void *)result;
92494   return jresult;
92495 }
92496
92497
92498 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_2(void * jarg1) {
92499   void * jresult ;
92500   Dali::Toolkit::Internal::AsyncImageLoader *arg1 = (Dali::Toolkit::Internal::AsyncImageLoader *) 0 ;
92501   Dali::Toolkit::AsyncImageLoader *result = 0 ;
92502
92503   arg1 = (Dali::Toolkit::Internal::AsyncImageLoader *)jarg1;
92504   {
92505     try {
92506       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader(arg1);
92507     } catch (std::out_of_range& e) {
92508       {
92509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92510       };
92511     } catch (std::exception& e) {
92512       {
92513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92514       };
92515     } catch (Dali::DaliException e) {
92516       {
92517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92518       };
92519     } catch (...) {
92520       {
92521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92522       };
92523     }
92524   }
92525
92526   jresult = (void *)result;
92527   return jresult;
92528 }
92529
92530
92531 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_0(char * jarg1) {
92532   void * jresult ;
92533   std::string *arg1 = 0 ;
92534   Dali::PixelData result;
92535
92536   if (!jarg1) {
92537     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92538     return 0;
92539   }
92540   std::string arg1_str(jarg1);
92541   arg1 = &arg1_str;
92542   {
92543     try {
92544       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1);
92545     } catch (std::out_of_range& e) {
92546       {
92547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92548       };
92549     } catch (std::exception& e) {
92550       {
92551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92552       };
92553     } catch (Dali::DaliException e) {
92554       {
92555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92556       };
92557     } catch (...) {
92558       {
92559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92560       };
92561     }
92562   }
92563
92564   jresult = new Dali::PixelData((const Dali::PixelData &)result);
92565
92566   //argout typemap for const std::string&
92567
92568   return jresult;
92569 }
92570
92571
92572 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_1(char * jarg1, void * jarg2) {
92573   void * jresult ;
92574   std::string *arg1 = 0 ;
92575   Dali::ImageDimensions arg2 ;
92576   Dali::ImageDimensions *argp2 ;
92577   Dali::PixelData result;
92578
92579   if (!jarg1) {
92580     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92581     return 0;
92582   }
92583   std::string arg1_str(jarg1);
92584   arg1 = &arg1_str;
92585   argp2 = (Dali::ImageDimensions *)jarg2;
92586   if (!argp2) {
92587     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
92588     return 0;
92589   }
92590   arg2 = *argp2;
92591   {
92592     try {
92593       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2);
92594     } catch (std::out_of_range& e) {
92595       {
92596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92597       };
92598     } catch (std::exception& e) {
92599       {
92600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92601       };
92602     } catch (Dali::DaliException e) {
92603       {
92604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92605       };
92606     } catch (...) {
92607       {
92608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92609       };
92610     }
92611   }
92612
92613   jresult = new Dali::PixelData((const Dali::PixelData &)result);
92614
92615   //argout typemap for const std::string&
92616
92617   return jresult;
92618 }
92619
92620
92621 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
92622   void * jresult ;
92623   std::string *arg1 = 0 ;
92624   Dali::ImageDimensions arg2 ;
92625   Dali::FittingMode::Type arg3 ;
92626   Dali::SamplingMode::Type arg4 ;
92627   bool arg5 ;
92628   Dali::ImageDimensions *argp2 ;
92629   Dali::PixelData result;
92630
92631   if (!jarg1) {
92632     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92633     return 0;
92634   }
92635   std::string arg1_str(jarg1);
92636   arg1 = &arg1_str;
92637   argp2 = (Dali::ImageDimensions *)jarg2;
92638   if (!argp2) {
92639     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
92640     return 0;
92641   }
92642   arg2 = *argp2;
92643   arg3 = (Dali::FittingMode::Type)jarg3;
92644   arg4 = (Dali::SamplingMode::Type)jarg4;
92645   arg5 = jarg5 ? true : false;
92646   {
92647     try {
92648       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2,arg3,arg4,arg5);
92649     } catch (std::out_of_range& e) {
92650       {
92651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92652       };
92653     } catch (std::exception& e) {
92654       {
92655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92656       };
92657     } catch (Dali::DaliException e) {
92658       {
92659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92660       };
92661     } catch (...) {
92662       {
92663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92664       };
92665     }
92666   }
92667
92668   jresult = new Dali::PixelData((const Dali::PixelData &)result);
92669
92670   //argout typemap for const std::string&
92671
92672   return jresult;
92673 }
92674
92675
92676 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomAlgorithmInterface(void * jarg1) {
92677   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
92678
92679   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
92680   {
92681     try {
92682       delete arg1;
92683     } catch (std::out_of_range& e) {
92684       {
92685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92686       };
92687     } catch (std::exception& e) {
92688       {
92689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92690       };
92691     } catch (Dali::DaliException e) {
92692       {
92693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92694       };
92695     } catch (...) {
92696       {
92697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92698       };
92699     }
92700   }
92701
92702 }
92703
92704
92705 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_GetNextFocusableActor(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
92706   void * jresult ;
92707   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
92708   Dali::Actor arg2 ;
92709   Dali::Actor arg3 ;
92710   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
92711   Dali::Actor *argp2 ;
92712   Dali::Actor *argp3 ;
92713   Dali::Actor result;
92714
92715   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
92716   argp2 = (Dali::Actor *)jarg2;
92717   if (!argp2) {
92718     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
92719     return 0;
92720   }
92721   arg2 = *argp2;
92722   argp3 = (Dali::Actor *)jarg3;
92723   if (!argp3) {
92724     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
92725     return 0;
92726   }
92727   arg3 = *argp3;
92728   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
92729   {
92730     try {
92731       result = (arg1)->GetNextFocusableActor(arg2,arg3,arg4);
92732     } catch (std::out_of_range& e) {
92733       {
92734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92735       };
92736     } catch (std::exception& e) {
92737       {
92738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92739       };
92740     } catch (Dali::DaliException e) {
92741       {
92742         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92743       };
92744     } catch (...) {
92745       {
92746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92747       };
92748     }
92749   }
92750
92751   jresult = new Dali::Actor((const Dali::Actor &)result);
92752   return jresult;
92753 }
92754
92755
92756 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomAlgorithmInterface() {
92757   void * jresult ;
92758   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *result = 0 ;
92759
92760   {
92761     try {
92762       result = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)new SwigDirector_CustomAlgorithmInterface();
92763     } catch (std::out_of_range& e) {
92764       {
92765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92766       };
92767     } catch (std::exception& e) {
92768       {
92769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92770       };
92771     } catch (Dali::DaliException e) {
92772       {
92773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92774       };
92775     } catch (...) {
92776       {
92777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92778       };
92779     }
92780   }
92781
92782   jresult = (void *)result;
92783   return jresult;
92784 }
92785
92786
92787 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_director_connect(void *objarg, SwigDirector_CustomAlgorithmInterface::SWIG_Callback0_t callback0) {
92788   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *obj = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)objarg;
92789   SwigDirector_CustomAlgorithmInterface *director = dynamic_cast<SwigDirector_CustomAlgorithmInterface *>(obj);
92790   if (director) {
92791     director->swig_connect_director(callback0);
92792   }
92793 }
92794
92795
92796 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetCustomAlgorithm(void * jarg1, void * jarg2) {
92797   KeyboardFocusManager arg1 ;
92798   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg2 = 0 ;
92799   KeyboardFocusManager *argp1 ;
92800
92801   argp1 = (KeyboardFocusManager *)jarg1;
92802   if (!argp1) {
92803     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
92804     return ;
92805   }
92806   arg1 = *argp1;
92807   arg2 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg2;
92808   if (!arg2) {
92809     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface & type is null", 0);
92810     return ;
92811   }
92812   {
92813     try {
92814       Dali::Toolkit::DevelKeyboardFocusManager::SetCustomAlgorithm(arg1,*arg2);
92815     } catch (std::out_of_range& e) {
92816       {
92817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92818       };
92819     } catch (std::exception& e) {
92820       {
92821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92822       };
92823     } catch (Dali::DaliException e) {
92824       {
92825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92826       };
92827     } catch (...) {
92828       {
92829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92830       };
92831     }
92832   }
92833
92834 }
92835
92836
92837 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Clear(void * jarg1) {
92838   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92839
92840   arg1 = (std::vector< unsigned int > *)jarg1;
92841   {
92842     try {
92843       (arg1)->clear();
92844     } catch (std::out_of_range& e) {
92845       {
92846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92847       };
92848     } catch (std::exception& e) {
92849       {
92850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92851       };
92852     } catch (Dali::DaliException e) {
92853       {
92854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92855       };
92856     } catch (...) {
92857       {
92858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92859       };
92860     }
92861   }
92862
92863 }
92864
92865
92866 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Add(void * jarg1, unsigned int jarg2) {
92867   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92868   unsigned int *arg2 = 0 ;
92869   unsigned int temp2 ;
92870
92871   arg1 = (std::vector< unsigned int > *)jarg1;
92872   temp2 = (unsigned int)jarg2;
92873   arg2 = &temp2;
92874   {
92875     try {
92876       (arg1)->push_back((unsigned int const &)*arg2);
92877     } catch (std::out_of_range& e) {
92878       {
92879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92880       };
92881     } catch (std::exception& e) {
92882       {
92883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92884       };
92885     } catch (Dali::DaliException e) {
92886       {
92887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92888       };
92889     } catch (...) {
92890       {
92891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92892       };
92893     }
92894   }
92895
92896 }
92897
92898
92899 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_size(void * jarg1) {
92900   unsigned long jresult ;
92901   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92902   std::vector< unsigned int >::size_type result;
92903
92904   arg1 = (std::vector< unsigned int > *)jarg1;
92905   {
92906     try {
92907       result = ((std::vector< unsigned int > const *)arg1)->size();
92908     } catch (std::out_of_range& e) {
92909       {
92910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92911       };
92912     } catch (std::exception& e) {
92913       {
92914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92915       };
92916     } catch (Dali::DaliException e) {
92917       {
92918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92919       };
92920     } catch (...) {
92921       {
92922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92923       };
92924     }
92925   }
92926
92927   jresult = (unsigned long)result;
92928   return jresult;
92929 }
92930
92931
92932 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_capacity(void * jarg1) {
92933   unsigned long jresult ;
92934   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92935   std::vector< unsigned int >::size_type result;
92936
92937   arg1 = (std::vector< unsigned int > *)jarg1;
92938   {
92939     try {
92940       result = ((std::vector< unsigned int > const *)arg1)->capacity();
92941     } catch (std::out_of_range& e) {
92942       {
92943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92944       };
92945     } catch (std::exception& e) {
92946       {
92947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92948       };
92949     } catch (Dali::DaliException e) {
92950       {
92951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92952       };
92953     } catch (...) {
92954       {
92955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92956       };
92957     }
92958   }
92959
92960   jresult = (unsigned long)result;
92961   return jresult;
92962 }
92963
92964
92965 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_reserve(void * jarg1, unsigned long jarg2) {
92966   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92967   std::vector< unsigned int >::size_type arg2 ;
92968
92969   arg1 = (std::vector< unsigned int > *)jarg1;
92970   arg2 = (std::vector< unsigned int >::size_type)jarg2;
92971   {
92972     try {
92973       (arg1)->reserve(arg2);
92974     } catch (std::out_of_range& e) {
92975       {
92976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92977       };
92978     } catch (std::exception& e) {
92979       {
92980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92981       };
92982     } catch (Dali::DaliException e) {
92983       {
92984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92985       };
92986     } catch (...) {
92987       {
92988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92989       };
92990     }
92991   }
92992
92993 }
92994
92995
92996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_0() {
92997   void * jresult ;
92998   std::vector< unsigned int > *result = 0 ;
92999
93000   {
93001     try {
93002       result = (std::vector< unsigned int > *)new std::vector< unsigned int >();
93003     } catch (std::out_of_range& e) {
93004       {
93005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93006       };
93007     } catch (std::exception& e) {
93008       {
93009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93010       };
93011     } catch (Dali::DaliException e) {
93012       {
93013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93014       };
93015     } catch (...) {
93016       {
93017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93018       };
93019     }
93020   }
93021
93022   jresult = (void *)result;
93023   return jresult;
93024 }
93025
93026
93027 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_1(void * jarg1) {
93028   void * jresult ;
93029   std::vector< unsigned int > *arg1 = 0 ;
93030   std::vector< unsigned int > *result = 0 ;
93031
93032   arg1 = (std::vector< unsigned int > *)jarg1;
93033   if (!arg1) {
93034     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
93035     return 0;
93036   }
93037   {
93038     try {
93039       result = (std::vector< unsigned int > *)new std::vector< unsigned int >((std::vector< unsigned int > const &)*arg1);
93040     } catch (std::out_of_range& e) {
93041       {
93042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93043       };
93044     } catch (std::exception& e) {
93045       {
93046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93047       };
93048     } catch (Dali::DaliException e) {
93049       {
93050         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93051       };
93052     } catch (...) {
93053       {
93054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93055       };
93056     }
93057   }
93058
93059   jresult = (void *)result;
93060   return jresult;
93061 }
93062
93063
93064 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_2(int jarg1) {
93065   void * jresult ;
93066   int arg1 ;
93067   std::vector< unsigned int > *result = 0 ;
93068
93069   arg1 = (int)jarg1;
93070   {
93071     try {
93072       try {
93073         result = (std::vector< unsigned int > *)new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(arg1);
93074       }
93075       catch(std::out_of_range &_e) {
93076         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93077         return 0;
93078       }
93079
93080     } catch (std::out_of_range& e) {
93081       {
93082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93083       };
93084     } catch (std::exception& e) {
93085       {
93086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93087       };
93088     } catch (Dali::DaliException e) {
93089       {
93090         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93091       };
93092     } catch (...) {
93093       {
93094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93095       };
93096     }
93097   }
93098
93099   jresult = (void *)result;
93100   return jresult;
93101 }
93102
93103
93104 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitemcopy(void * jarg1, int jarg2) {
93105   unsigned int jresult ;
93106   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93107   int arg2 ;
93108   unsigned int result;
93109
93110   arg1 = (std::vector< unsigned int > *)jarg1;
93111   arg2 = (int)jarg2;
93112   {
93113     try {
93114       try {
93115         result = (unsigned int)std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(arg1,arg2);
93116       }
93117       catch(std::out_of_range &_e) {
93118         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93119         return 0;
93120       }
93121
93122     } catch (std::out_of_range& e) {
93123       {
93124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93125       };
93126     } catch (std::exception& e) {
93127       {
93128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93129       };
93130     } catch (Dali::DaliException e) {
93131       {
93132         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93133       };
93134     } catch (...) {
93135       {
93136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93137       };
93138     }
93139   }
93140
93141   jresult = result;
93142   return jresult;
93143 }
93144
93145
93146 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitem(void * jarg1, int jarg2) {
93147   unsigned int jresult ;
93148   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93149   int arg2 ;
93150   unsigned int *result = 0 ;
93151
93152   arg1 = (std::vector< unsigned int > *)jarg1;
93153   arg2 = (int)jarg2;
93154   {
93155     try {
93156       try {
93157         result = (unsigned int *) &std_vector_Sl_unsigned_SS_int_Sg__getitem(arg1,arg2);
93158       }
93159       catch(std::out_of_range &_e) {
93160         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93161         return 0;
93162       }
93163
93164     } catch (std::out_of_range& e) {
93165       {
93166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93167       };
93168     } catch (std::exception& e) {
93169       {
93170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93171       };
93172     } catch (Dali::DaliException e) {
93173       {
93174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93175       };
93176     } catch (...) {
93177       {
93178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93179       };
93180     }
93181   }
93182
93183   jresult = *result;
93184   return jresult;
93185 }
93186
93187
93188 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_setitem(void * jarg1, int jarg2, unsigned int jarg3) {
93189   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93190   int arg2 ;
93191   unsigned int *arg3 = 0 ;
93192   unsigned int temp3 ;
93193
93194   arg1 = (std::vector< unsigned int > *)jarg1;
93195   arg2 = (int)jarg2;
93196   temp3 = (unsigned int)jarg3;
93197   arg3 = &temp3;
93198   {
93199     try {
93200       try {
93201         std_vector_Sl_unsigned_SS_int_Sg__setitem(arg1,arg2,(unsigned int const &)*arg3);
93202       }
93203       catch(std::out_of_range &_e) {
93204         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93205         return ;
93206       }
93207
93208     } catch (std::out_of_range& e) {
93209       {
93210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93211       };
93212     } catch (std::exception& e) {
93213       {
93214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93215       };
93216     } catch (Dali::DaliException e) {
93217       {
93218         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93219       };
93220     } catch (...) {
93221       {
93222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93223       };
93224     }
93225   }
93226
93227 }
93228
93229
93230 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_AddRange(void * jarg1, void * jarg2) {
93231   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93232   std::vector< unsigned int > *arg2 = 0 ;
93233
93234   arg1 = (std::vector< unsigned int > *)jarg1;
93235   arg2 = (std::vector< unsigned int > *)jarg2;
93236   if (!arg2) {
93237     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
93238     return ;
93239   }
93240   {
93241     try {
93242       std_vector_Sl_unsigned_SS_int_Sg__AddRange(arg1,(std::vector< unsigned int > const &)*arg2);
93243     } catch (std::out_of_range& e) {
93244       {
93245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93246       };
93247     } catch (std::exception& e) {
93248       {
93249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93250       };
93251     } catch (Dali::DaliException e) {
93252       {
93253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93254       };
93255     } catch (...) {
93256       {
93257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93258       };
93259     }
93260   }
93261
93262 }
93263
93264
93265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
93266   void * jresult ;
93267   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93268   int arg2 ;
93269   int arg3 ;
93270   std::vector< unsigned int > *result = 0 ;
93271
93272   arg1 = (std::vector< unsigned int > *)jarg1;
93273   arg2 = (int)jarg2;
93274   arg3 = (int)jarg3;
93275   {
93276     try {
93277       try {
93278         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__GetRange(arg1,arg2,arg3);
93279       }
93280       catch(std::out_of_range &_e) {
93281         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93282         return 0;
93283       }
93284       catch(std::invalid_argument &_e) {
93285         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
93286         return 0;
93287       }
93288
93289     } catch (std::out_of_range& e) {
93290       {
93291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93292       };
93293     } catch (std::exception& e) {
93294       {
93295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93296       };
93297     } catch (Dali::DaliException e) {
93298       {
93299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93300       };
93301     } catch (...) {
93302       {
93303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93304       };
93305     }
93306   }
93307
93308   jresult = (void *)result;
93309   return jresult;
93310 }
93311
93312
93313 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Insert(void * jarg1, int jarg2, unsigned int jarg3) {
93314   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93315   int arg2 ;
93316   unsigned int *arg3 = 0 ;
93317   unsigned int temp3 ;
93318
93319   arg1 = (std::vector< unsigned int > *)jarg1;
93320   arg2 = (int)jarg2;
93321   temp3 = (unsigned int)jarg3;
93322   arg3 = &temp3;
93323   {
93324     try {
93325       try {
93326         std_vector_Sl_unsigned_SS_int_Sg__Insert(arg1,arg2,(unsigned int const &)*arg3);
93327       }
93328       catch(std::out_of_range &_e) {
93329         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93330         return ;
93331       }
93332
93333     } catch (std::out_of_range& e) {
93334       {
93335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93336       };
93337     } catch (std::exception& e) {
93338       {
93339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93340       };
93341     } catch (Dali::DaliException e) {
93342       {
93343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93344       };
93345     } catch (...) {
93346       {
93347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93348       };
93349     }
93350   }
93351
93352 }
93353
93354
93355 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
93356   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93357   int arg2 ;
93358   std::vector< unsigned int > *arg3 = 0 ;
93359
93360   arg1 = (std::vector< unsigned int > *)jarg1;
93361   arg2 = (int)jarg2;
93362   arg3 = (std::vector< unsigned int > *)jarg3;
93363   if (!arg3) {
93364     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
93365     return ;
93366   }
93367   {
93368     try {
93369       try {
93370         std_vector_Sl_unsigned_SS_int_Sg__InsertRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
93371       }
93372       catch(std::out_of_range &_e) {
93373         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93374         return ;
93375       }
93376
93377     } catch (std::out_of_range& e) {
93378       {
93379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93380       };
93381     } catch (std::exception& e) {
93382       {
93383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93384       };
93385     } catch (Dali::DaliException e) {
93386       {
93387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93388       };
93389     } catch (...) {
93390       {
93391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93392       };
93393     }
93394   }
93395
93396 }
93397
93398
93399 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveAt(void * jarg1, int jarg2) {
93400   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93401   int arg2 ;
93402
93403   arg1 = (std::vector< unsigned int > *)jarg1;
93404   arg2 = (int)jarg2;
93405   {
93406     try {
93407       try {
93408         std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(arg1,arg2);
93409       }
93410       catch(std::out_of_range &_e) {
93411         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93412         return ;
93413       }
93414
93415     } catch (std::out_of_range& e) {
93416       {
93417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93418       };
93419     } catch (std::exception& e) {
93420       {
93421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93422       };
93423     } catch (Dali::DaliException e) {
93424       {
93425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93426       };
93427     } catch (...) {
93428       {
93429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93430       };
93431     }
93432   }
93433
93434 }
93435
93436
93437 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
93438   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93439   int arg2 ;
93440   int arg3 ;
93441
93442   arg1 = (std::vector< unsigned int > *)jarg1;
93443   arg2 = (int)jarg2;
93444   arg3 = (int)jarg3;
93445   {
93446     try {
93447       try {
93448         std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(arg1,arg2,arg3);
93449       }
93450       catch(std::out_of_range &_e) {
93451         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93452         return ;
93453       }
93454       catch(std::invalid_argument &_e) {
93455         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
93456         return ;
93457       }
93458
93459     } catch (std::out_of_range& e) {
93460       {
93461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93462       };
93463     } catch (std::exception& e) {
93464       {
93465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93466       };
93467     } catch (Dali::DaliException e) {
93468       {
93469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93470       };
93471     } catch (...) {
93472       {
93473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93474       };
93475     }
93476   }
93477
93478 }
93479
93480
93481 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_Repeat(unsigned int jarg1, int jarg2) {
93482   void * jresult ;
93483   unsigned int *arg1 = 0 ;
93484   int arg2 ;
93485   unsigned int temp1 ;
93486   std::vector< unsigned int > *result = 0 ;
93487
93488   temp1 = (unsigned int)jarg1;
93489   arg1 = &temp1;
93490   arg2 = (int)jarg2;
93491   {
93492     try {
93493       try {
93494         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__Repeat((unsigned int const &)*arg1,arg2);
93495       }
93496       catch(std::out_of_range &_e) {
93497         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93498         return 0;
93499       }
93500
93501     } catch (std::out_of_range& e) {
93502       {
93503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93504       };
93505     } catch (std::exception& e) {
93506       {
93507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93508       };
93509     } catch (Dali::DaliException e) {
93510       {
93511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93512       };
93513     } catch (...) {
93514       {
93515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93516       };
93517     }
93518   }
93519
93520   jresult = (void *)result;
93521   return jresult;
93522 }
93523
93524
93525 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_0(void * jarg1) {
93526   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93527
93528   arg1 = (std::vector< unsigned int > *)jarg1;
93529   {
93530     try {
93531       std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(arg1);
93532     } catch (std::out_of_range& e) {
93533       {
93534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93535       };
93536     } catch (std::exception& e) {
93537       {
93538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93539       };
93540     } catch (Dali::DaliException e) {
93541       {
93542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93543       };
93544     } catch (...) {
93545       {
93546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93547       };
93548     }
93549   }
93550
93551 }
93552
93553
93554 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
93555   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93556   int arg2 ;
93557   int arg3 ;
93558
93559   arg1 = (std::vector< unsigned int > *)jarg1;
93560   arg2 = (int)jarg2;
93561   arg3 = (int)jarg3;
93562   {
93563     try {
93564       try {
93565         std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
93566       }
93567       catch(std::out_of_range &_e) {
93568         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93569         return ;
93570       }
93571       catch(std::invalid_argument &_e) {
93572         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
93573         return ;
93574       }
93575
93576     } catch (std::out_of_range& e) {
93577       {
93578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93579       };
93580     } catch (std::exception& e) {
93581       {
93582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93583       };
93584     } catch (Dali::DaliException e) {
93585       {
93586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93587       };
93588     } catch (...) {
93589       {
93590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93591       };
93592     }
93593   }
93594
93595 }
93596
93597
93598 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
93599   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93600   int arg2 ;
93601   std::vector< unsigned int > *arg3 = 0 ;
93602
93603   arg1 = (std::vector< unsigned int > *)jarg1;
93604   arg2 = (int)jarg2;
93605   arg3 = (std::vector< unsigned int > *)jarg3;
93606   if (!arg3) {
93607     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
93608     return ;
93609   }
93610   {
93611     try {
93612       try {
93613         std_vector_Sl_unsigned_SS_int_Sg__SetRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
93614       }
93615       catch(std::out_of_range &_e) {
93616         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93617         return ;
93618       }
93619
93620     } catch (std::out_of_range& e) {
93621       {
93622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93623       };
93624     } catch (std::exception& e) {
93625       {
93626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93627       };
93628     } catch (Dali::DaliException e) {
93629       {
93630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93631       };
93632     } catch (...) {
93633       {
93634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93635       };
93636     }
93637   }
93638
93639 }
93640
93641
93642 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Contains(void * jarg1, unsigned int jarg2) {
93643   unsigned int jresult ;
93644   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93645   unsigned int *arg2 = 0 ;
93646   unsigned int temp2 ;
93647   bool result;
93648
93649   arg1 = (std::vector< unsigned int > *)jarg1;
93650   temp2 = (unsigned int)jarg2;
93651   arg2 = &temp2;
93652   {
93653     try {
93654       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Contains(arg1,(unsigned int const &)*arg2);
93655     } catch (std::out_of_range& e) {
93656       {
93657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93658       };
93659     } catch (std::exception& e) {
93660       {
93661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93662       };
93663     } catch (Dali::DaliException e) {
93664       {
93665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93666       };
93667     } catch (...) {
93668       {
93669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93670       };
93671     }
93672   }
93673
93674   jresult = result;
93675   return jresult;
93676 }
93677
93678
93679 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_IndexOf(void * jarg1, unsigned int jarg2) {
93680   int jresult ;
93681   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93682   unsigned int *arg2 = 0 ;
93683   unsigned int temp2 ;
93684   int result;
93685
93686   arg1 = (std::vector< unsigned int > *)jarg1;
93687   temp2 = (unsigned int)jarg2;
93688   arg2 = &temp2;
93689   {
93690     try {
93691       result = (int)std_vector_Sl_unsigned_SS_int_Sg__IndexOf(arg1,(unsigned int const &)*arg2);
93692     } catch (std::out_of_range& e) {
93693       {
93694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93695       };
93696     } catch (std::exception& e) {
93697       {
93698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93699       };
93700     } catch (Dali::DaliException e) {
93701       {
93702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93703       };
93704     } catch (...) {
93705       {
93706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93707       };
93708     }
93709   }
93710
93711   jresult = result;
93712   return jresult;
93713 }
93714
93715
93716 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_LastIndexOf(void * jarg1, unsigned int jarg2) {
93717   int jresult ;
93718   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93719   unsigned int *arg2 = 0 ;
93720   unsigned int temp2 ;
93721   int result;
93722
93723   arg1 = (std::vector< unsigned int > *)jarg1;
93724   temp2 = (unsigned int)jarg2;
93725   arg2 = &temp2;
93726   {
93727     try {
93728       result = (int)std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(arg1,(unsigned int const &)*arg2);
93729     } catch (std::out_of_range& e) {
93730       {
93731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93732       };
93733     } catch (std::exception& e) {
93734       {
93735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93736       };
93737     } catch (Dali::DaliException e) {
93738       {
93739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93740       };
93741     } catch (...) {
93742       {
93743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93744       };
93745     }
93746   }
93747
93748   jresult = result;
93749   return jresult;
93750 }
93751
93752
93753 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Remove(void * jarg1, unsigned int jarg2) {
93754   unsigned int jresult ;
93755   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93756   unsigned int *arg2 = 0 ;
93757   unsigned int temp2 ;
93758   bool result;
93759
93760   arg1 = (std::vector< unsigned int > *)jarg1;
93761   temp2 = (unsigned int)jarg2;
93762   arg2 = &temp2;
93763   {
93764     try {
93765       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Remove(arg1,(unsigned int const &)*arg2);
93766     } catch (std::out_of_range& e) {
93767       {
93768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93769       };
93770     } catch (std::exception& e) {
93771       {
93772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93773       };
93774     } catch (Dali::DaliException e) {
93775       {
93776         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93777       };
93778     } catch (...) {
93779       {
93780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93781       };
93782     }
93783   }
93784
93785   jresult = result;
93786   return jresult;
93787 }
93788
93789
93790 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemIdContainer(void * jarg1) {
93791   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93792
93793   arg1 = (std::vector< unsigned int > *)jarg1;
93794   {
93795     try {
93796       delete arg1;
93797     } catch (std::out_of_range& e) {
93798       {
93799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93800       };
93801     } catch (std::exception& e) {
93802       {
93803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93804       };
93805     } catch (Dali::DaliException e) {
93806       {
93807         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93808       };
93809     } catch (...) {
93810       {
93811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93812       };
93813     }
93814   }
93815
93816 }
93817
93818
93819 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_0() {
93820   void * jresult ;
93821   std::pair< unsigned int,Dali::Actor > *result = 0 ;
93822
93823   {
93824     try {
93825       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >();
93826     } catch (std::out_of_range& e) {
93827       {
93828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93829       };
93830     } catch (std::exception& e) {
93831       {
93832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93833       };
93834     } catch (Dali::DaliException e) {
93835       {
93836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93837       };
93838     } catch (...) {
93839       {
93840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93841       };
93842     }
93843   }
93844
93845   jresult = (void *)result;
93846   return jresult;
93847 }
93848
93849
93850 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_1(unsigned int jarg1, void * jarg2) {
93851   void * jresult ;
93852   unsigned int arg1 ;
93853   Dali::Actor arg2 ;
93854   Dali::Actor *argp2 ;
93855   std::pair< unsigned int,Dali::Actor > *result = 0 ;
93856
93857   arg1 = (unsigned int)jarg1;
93858   argp2 = (Dali::Actor *)jarg2;
93859   if (!argp2) {
93860     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
93861     return 0;
93862   }
93863   arg2 = *argp2;
93864   {
93865     try {
93866       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >(arg1,arg2);
93867     } catch (std::out_of_range& e) {
93868       {
93869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93870       };
93871     } catch (std::exception& e) {
93872       {
93873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93874       };
93875     } catch (Dali::DaliException e) {
93876       {
93877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93878       };
93879     } catch (...) {
93880       {
93881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93882       };
93883     }
93884   }
93885
93886   jresult = (void *)result;
93887   return jresult;
93888 }
93889
93890
93891 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_2(void * jarg1) {
93892   void * jresult ;
93893   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
93894   std::pair< unsigned int,Dali::Actor > *result = 0 ;
93895
93896   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93897   if (!arg1) {
93898     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
93899     return 0;
93900   }
93901   {
93902     try {
93903       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >((std::pair< unsigned int,Dali::Actor > const &)*arg1);
93904     } catch (std::out_of_range& e) {
93905       {
93906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93907       };
93908     } catch (std::exception& e) {
93909       {
93910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93911       };
93912     } catch (Dali::DaliException e) {
93913       {
93914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93915       };
93916     } catch (...) {
93917       {
93918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93919       };
93920     }
93921   }
93922
93923   jresult = (void *)result;
93924   return jresult;
93925 }
93926
93927
93928 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_first_set(void * jarg1, unsigned int jarg2) {
93929   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93930   unsigned int arg2 ;
93931
93932   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93933   arg2 = (unsigned int)jarg2;
93934   if (arg1) (arg1)->first = arg2;
93935 }
93936
93937
93938 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Item_first_get(void * jarg1) {
93939   unsigned int jresult ;
93940   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93941   unsigned int result;
93942
93943   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93944   result = (unsigned int) ((arg1)->first);
93945   jresult = result;
93946   return jresult;
93947 }
93948
93949
93950 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_second_set(void * jarg1, void * jarg2) {
93951   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93952   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
93953
93954   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93955   arg2 = (Dali::Actor *)jarg2;
93956   if (arg1) (arg1)->second = *arg2;
93957 }
93958
93959
93960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Item_second_get(void * jarg1) {
93961   void * jresult ;
93962   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93963   Dali::Actor *result = 0 ;
93964
93965   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93966   result = (Dali::Actor *)& ((arg1)->second);
93967   jresult = (void *)result;
93968   return jresult;
93969 }
93970
93971
93972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Item(void * jarg1) {
93973   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93974
93975   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93976   {
93977     try {
93978       delete arg1;
93979     } catch (std::out_of_range& e) {
93980       {
93981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93982       };
93983     } catch (std::exception& e) {
93984       {
93985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93986       };
93987     } catch (Dali::DaliException e) {
93988       {
93989         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93990       };
93991     } catch (...) {
93992       {
93993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93994       };
93995     }
93996   }
93997
93998 }
93999
94000
94001 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Clear(void * jarg1) {
94002   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94003
94004   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94005   {
94006     try {
94007       (arg1)->clear();
94008     } catch (std::out_of_range& e) {
94009       {
94010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94011       };
94012     } catch (std::exception& e) {
94013       {
94014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94015       };
94016     } catch (Dali::DaliException e) {
94017       {
94018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94019       };
94020     } catch (...) {
94021       {
94022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94023       };
94024     }
94025   }
94026
94027 }
94028
94029
94030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Add(void * jarg1, void * jarg2) {
94031   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94032   std::pair< unsigned int,Dali::Actor > *arg2 = 0 ;
94033
94034   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94035   arg2 = (std::pair< unsigned int,Dali::Actor > *)jarg2;
94036   if (!arg2) {
94037     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
94038     return ;
94039   }
94040   {
94041     try {
94042       (arg1)->push_back((std::pair< unsigned int,Dali::Actor > const &)*arg2);
94043     } catch (std::out_of_range& e) {
94044       {
94045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94046       };
94047     } catch (std::exception& e) {
94048       {
94049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94050       };
94051     } catch (Dali::DaliException e) {
94052       {
94053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94054       };
94055     } catch (...) {
94056       {
94057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94058       };
94059     }
94060   }
94061
94062 }
94063
94064
94065 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_size(void * jarg1) {
94066   unsigned long jresult ;
94067   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94068   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
94069
94070   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94071   {
94072     try {
94073       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->size();
94074     } catch (std::out_of_range& e) {
94075       {
94076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94077       };
94078     } catch (std::exception& e) {
94079       {
94080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94081       };
94082     } catch (Dali::DaliException e) {
94083       {
94084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94085       };
94086     } catch (...) {
94087       {
94088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94089       };
94090     }
94091   }
94092
94093   jresult = (unsigned long)result;
94094   return jresult;
94095 }
94096
94097
94098 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_capacity(void * jarg1) {
94099   unsigned long jresult ;
94100   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94101   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
94102
94103   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94104   {
94105     try {
94106       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->capacity();
94107     } catch (std::out_of_range& e) {
94108       {
94109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94110       };
94111     } catch (std::exception& e) {
94112       {
94113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94114       };
94115     } catch (Dali::DaliException e) {
94116       {
94117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94118       };
94119     } catch (...) {
94120       {
94121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94122       };
94123     }
94124   }
94125
94126   jresult = (unsigned long)result;
94127   return jresult;
94128 }
94129
94130
94131 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_reserve(void * jarg1, unsigned long jarg2) {
94132   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94133   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type arg2 ;
94134
94135   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94136   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > >::size_type)jarg2;
94137   {
94138     try {
94139       (arg1)->reserve(arg2);
94140     } catch (std::out_of_range& e) {
94141       {
94142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94143       };
94144     } catch (std::exception& e) {
94145       {
94146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94147       };
94148     } catch (Dali::DaliException e) {
94149       {
94150         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94151       };
94152     } catch (...) {
94153       {
94154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94155       };
94156     }
94157   }
94158
94159 }
94160
94161
94162 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_0() {
94163   void * jresult ;
94164   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
94165
94166   {
94167     try {
94168       result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)new std::vector< std::pair< unsigned int,Dali::Actor > >();
94169     } catch (std::out_of_range& e) {
94170       {
94171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94172       };
94173     } catch (std::exception& e) {
94174       {
94175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94176       };
94177     } catch (Dali::DaliException e) {
94178       {
94179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94180       };
94181     } catch (...) {
94182       {
94183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94184       };
94185     }
94186   }
94187
94188   jresult = (void *)result;
94189   return jresult;
94190 }
94191
94192
94193 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_1(void * jarg1) {
94194   void * jresult ;
94195   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = 0 ;
94196   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
94197
94198   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94199   if (!arg1) {
94200     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
94201     return 0;
94202   }
94203   {
94204     try {
94205       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);
94206     } catch (std::out_of_range& e) {
94207       {
94208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94209       };
94210     } catch (std::exception& e) {
94211       {
94212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94213       };
94214     } catch (Dali::DaliException e) {
94215       {
94216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94217       };
94218     } catch (...) {
94219       {
94220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94221       };
94222     }
94223   }
94224
94225   jresult = (void *)result;
94226   return jresult;
94227 }
94228
94229
94230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_2(int jarg1) {
94231   void * jresult ;
94232   int arg1 ;
94233   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
94234
94235   arg1 = (int)jarg1;
94236   {
94237     try {
94238       try {
94239         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);
94240       }
94241       catch(std::out_of_range &_e) {
94242         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94243         return 0;
94244       }
94245
94246     } catch (std::out_of_range& e) {
94247       {
94248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94249       };
94250     } catch (std::exception& e) {
94251       {
94252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94253       };
94254     } catch (Dali::DaliException e) {
94255       {
94256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94257       };
94258     } catch (...) {
94259       {
94260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94261       };
94262     }
94263   }
94264
94265   jresult = (void *)result;
94266   return jresult;
94267 }
94268
94269
94270 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitemcopy(void * jarg1, int jarg2) {
94271   void * jresult ;
94272   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94273   int arg2 ;
94274   std::pair< unsigned int,Dali::Actor > result;
94275
94276   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94277   arg2 = (int)jarg2;
94278   {
94279     try {
94280       try {
94281         result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(arg1,arg2);
94282       }
94283       catch(std::out_of_range &_e) {
94284         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94285         return 0;
94286       }
94287
94288     } catch (std::out_of_range& e) {
94289       {
94290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94291       };
94292     } catch (std::exception& e) {
94293       {
94294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94295       };
94296     } catch (Dali::DaliException e) {
94297       {
94298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94299       };
94300     } catch (...) {
94301       {
94302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94303       };
94304     }
94305   }
94306
94307   jresult = new std::pair< unsigned int,Dali::Actor >((const std::pair< unsigned int,Dali::Actor > &)result);
94308   return jresult;
94309 }
94310
94311
94312 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitem(void * jarg1, int jarg2) {
94313   void * jresult ;
94314   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94315   int arg2 ;
94316   std::pair< unsigned int,Dali::Actor > *result = 0 ;
94317
94318   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94319   arg2 = (int)jarg2;
94320   {
94321     try {
94322       try {
94323         result = (std::pair< unsigned int,Dali::Actor > *) &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(arg1,arg2);
94324       }
94325       catch(std::out_of_range &_e) {
94326         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94327         return 0;
94328       }
94329
94330     } catch (std::out_of_range& e) {
94331       {
94332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94333       };
94334     } catch (std::exception& e) {
94335       {
94336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94337       };
94338     } catch (Dali::DaliException e) {
94339       {
94340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94341       };
94342     } catch (...) {
94343       {
94344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94345       };
94346     }
94347   }
94348
94349   jresult = (void *)result;
94350   return jresult;
94351 }
94352
94353
94354 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
94355   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94356   int arg2 ;
94357   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
94358
94359   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94360   arg2 = (int)jarg2;
94361   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
94362   if (!arg3) {
94363     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
94364     return ;
94365   }
94366   {
94367     try {
94368       try {
94369         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);
94370       }
94371       catch(std::out_of_range &_e) {
94372         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94373         return ;
94374       }
94375
94376     } catch (std::out_of_range& e) {
94377       {
94378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94379       };
94380     } catch (std::exception& e) {
94381       {
94382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94383       };
94384     } catch (Dali::DaliException e) {
94385       {
94386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94387       };
94388     } catch (...) {
94389       {
94390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94391       };
94392     }
94393   }
94394
94395 }
94396
94397
94398 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_AddRange(void * jarg1, void * jarg2) {
94399   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94400   std::vector< std::pair< unsigned int,Dali::Actor > > *arg2 = 0 ;
94401
94402   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94403   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg2;
94404   if (!arg2) {
94405     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
94406     return ;
94407   }
94408   {
94409     try {
94410       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);
94411     } catch (std::out_of_range& e) {
94412       {
94413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94414       };
94415     } catch (std::exception& e) {
94416       {
94417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94418       };
94419     } catch (Dali::DaliException e) {
94420       {
94421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94422       };
94423     } catch (...) {
94424       {
94425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94426       };
94427     }
94428   }
94429
94430 }
94431
94432
94433 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
94434   void * jresult ;
94435   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94436   int arg2 ;
94437   int arg3 ;
94438   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
94439
94440   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94441   arg2 = (int)jarg2;
94442   arg3 = (int)jarg3;
94443   {
94444     try {
94445       try {
94446         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);
94447       }
94448       catch(std::out_of_range &_e) {
94449         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94450         return 0;
94451       }
94452       catch(std::invalid_argument &_e) {
94453         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
94454         return 0;
94455       }
94456
94457     } catch (std::out_of_range& e) {
94458       {
94459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94460       };
94461     } catch (std::exception& e) {
94462       {
94463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94464       };
94465     } catch (Dali::DaliException e) {
94466       {
94467         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94468       };
94469     } catch (...) {
94470       {
94471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94472       };
94473     }
94474   }
94475
94476   jresult = (void *)result;
94477   return jresult;
94478 }
94479
94480
94481 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
94482   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94483   int arg2 ;
94484   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
94485
94486   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94487   arg2 = (int)jarg2;
94488   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
94489   if (!arg3) {
94490     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
94491     return ;
94492   }
94493   {
94494     try {
94495       try {
94496         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);
94497       }
94498       catch(std::out_of_range &_e) {
94499         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94500         return ;
94501       }
94502
94503     } catch (std::out_of_range& e) {
94504       {
94505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94506       };
94507     } catch (std::exception& e) {
94508       {
94509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94510       };
94511     } catch (Dali::DaliException e) {
94512       {
94513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94514       };
94515     } catch (...) {
94516       {
94517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94518       };
94519     }
94520   }
94521
94522 }
94523
94524
94525 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
94526   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94527   int arg2 ;
94528   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
94529
94530   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94531   arg2 = (int)jarg2;
94532   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
94533   if (!arg3) {
94534     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
94535     return ;
94536   }
94537   {
94538     try {
94539       try {
94540         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);
94541       }
94542       catch(std::out_of_range &_e) {
94543         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94544         return ;
94545       }
94546
94547     } catch (std::out_of_range& e) {
94548       {
94549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94550       };
94551     } catch (std::exception& e) {
94552       {
94553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94554       };
94555     } catch (Dali::DaliException e) {
94556       {
94557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94558       };
94559     } catch (...) {
94560       {
94561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94562       };
94563     }
94564   }
94565
94566 }
94567
94568
94569 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveAt(void * jarg1, int jarg2) {
94570   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94571   int arg2 ;
94572
94573   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94574   arg2 = (int)jarg2;
94575   {
94576     try {
94577       try {
94578         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(arg1,arg2);
94579       }
94580       catch(std::out_of_range &_e) {
94581         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94582         return ;
94583       }
94584
94585     } catch (std::out_of_range& e) {
94586       {
94587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94588       };
94589     } catch (std::exception& e) {
94590       {
94591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94592       };
94593     } catch (Dali::DaliException e) {
94594       {
94595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94596       };
94597     } catch (...) {
94598       {
94599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94600       };
94601     }
94602   }
94603
94604 }
94605
94606
94607 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
94608   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94609   int arg2 ;
94610   int arg3 ;
94611
94612   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94613   arg2 = (int)jarg2;
94614   arg3 = (int)jarg3;
94615   {
94616     try {
94617       try {
94618         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(arg1,arg2,arg3);
94619       }
94620       catch(std::out_of_range &_e) {
94621         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94622         return ;
94623       }
94624       catch(std::invalid_argument &_e) {
94625         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
94626         return ;
94627       }
94628
94629     } catch (std::out_of_range& e) {
94630       {
94631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94632       };
94633     } catch (std::exception& e) {
94634       {
94635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94636       };
94637     } catch (Dali::DaliException e) {
94638       {
94639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94640       };
94641     } catch (...) {
94642       {
94643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94644       };
94645     }
94646   }
94647
94648 }
94649
94650
94651 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_Repeat(void * jarg1, int jarg2) {
94652   void * jresult ;
94653   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
94654   int arg2 ;
94655   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
94656
94657   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
94658   if (!arg1) {
94659     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
94660     return 0;
94661   }
94662   arg2 = (int)jarg2;
94663   {
94664     try {
94665       try {
94666         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);
94667       }
94668       catch(std::out_of_range &_e) {
94669         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94670         return 0;
94671       }
94672
94673     } catch (std::out_of_range& e) {
94674       {
94675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94676       };
94677     } catch (std::exception& e) {
94678       {
94679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94680       };
94681     } catch (Dali::DaliException e) {
94682       {
94683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94684       };
94685     } catch (...) {
94686       {
94687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94688       };
94689     }
94690   }
94691
94692   jresult = (void *)result;
94693   return jresult;
94694 }
94695
94696
94697 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_0(void * jarg1) {
94698   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94699
94700   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94701   {
94702     try {
94703       std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(arg1);
94704     } catch (std::out_of_range& e) {
94705       {
94706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94707       };
94708     } catch (std::exception& e) {
94709       {
94710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94711       };
94712     } catch (Dali::DaliException e) {
94713       {
94714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94715       };
94716     } catch (...) {
94717       {
94718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94719       };
94720     }
94721   }
94722
94723 }
94724
94725
94726 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
94727   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94728   int arg2 ;
94729   int arg3 ;
94730
94731   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94732   arg2 = (int)jarg2;
94733   arg3 = (int)jarg3;
94734   {
94735     try {
94736       try {
94737         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
94738       }
94739       catch(std::out_of_range &_e) {
94740         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94741         return ;
94742       }
94743       catch(std::invalid_argument &_e) {
94744         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
94745         return ;
94746       }
94747
94748     } catch (std::out_of_range& e) {
94749       {
94750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94751       };
94752     } catch (std::exception& e) {
94753       {
94754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94755       };
94756     } catch (Dali::DaliException e) {
94757       {
94758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94759       };
94760     } catch (...) {
94761       {
94762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94763       };
94764     }
94765   }
94766
94767 }
94768
94769
94770 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
94771   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94772   int arg2 ;
94773   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
94774
94775   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94776   arg2 = (int)jarg2;
94777   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
94778   if (!arg3) {
94779     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
94780     return ;
94781   }
94782   {
94783     try {
94784       try {
94785         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);
94786       }
94787       catch(std::out_of_range &_e) {
94788         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94789         return ;
94790       }
94791
94792     } catch (std::out_of_range& e) {
94793       {
94794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94795       };
94796     } catch (std::exception& e) {
94797       {
94798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94799       };
94800     } catch (Dali::DaliException e) {
94801       {
94802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94803       };
94804     } catch (...) {
94805       {
94806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94807       };
94808     }
94809   }
94810
94811 }
94812
94813
94814 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemContainer(void * jarg1) {
94815   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94816
94817   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94818   {
94819     try {
94820       delete arg1;
94821     } catch (std::out_of_range& e) {
94822       {
94823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94824       };
94825     } catch (std::exception& e) {
94826       {
94827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94828       };
94829     } catch (Dali::DaliException e) {
94830       {
94831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94832       };
94833     } catch (...) {
94834       {
94835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94836       };
94837     }
94838   }
94839
94840 }
94841
94842
94843 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Clear(void * jarg1) {
94844   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94845
94846   arg1 = (std::vector< Dali::Actor > *)jarg1;
94847   {
94848     try {
94849       (arg1)->clear();
94850     } catch (std::out_of_range& e) {
94851       {
94852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94853       };
94854     } catch (std::exception& e) {
94855       {
94856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94857       };
94858     } catch (Dali::DaliException e) {
94859       {
94860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94861       };
94862     } catch (...) {
94863       {
94864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94865       };
94866     }
94867   }
94868
94869 }
94870
94871
94872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Add(void * jarg1, void * jarg2) {
94873   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94874   Dali::Actor *arg2 = 0 ;
94875
94876   arg1 = (std::vector< Dali::Actor > *)jarg1;
94877   arg2 = (Dali::Actor *)jarg2;
94878   if (!arg2) {
94879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
94880     return ;
94881   }
94882   {
94883     try {
94884       (arg1)->push_back((Dali::Actor const &)*arg2);
94885     } catch (std::out_of_range& e) {
94886       {
94887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94888       };
94889     } catch (std::exception& e) {
94890       {
94891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94892       };
94893     } catch (Dali::DaliException e) {
94894       {
94895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94896       };
94897     } catch (...) {
94898       {
94899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94900       };
94901     }
94902   }
94903
94904 }
94905
94906
94907 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_size(void * jarg1) {
94908   unsigned long jresult ;
94909   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94910   std::vector< Dali::Actor >::size_type result;
94911
94912   arg1 = (std::vector< Dali::Actor > *)jarg1;
94913   {
94914     try {
94915       result = ((std::vector< Dali::Actor > const *)arg1)->size();
94916     } catch (std::out_of_range& e) {
94917       {
94918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94919       };
94920     } catch (std::exception& e) {
94921       {
94922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94923       };
94924     } catch (Dali::DaliException e) {
94925       {
94926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94927       };
94928     } catch (...) {
94929       {
94930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94931       };
94932     }
94933   }
94934
94935   jresult = (unsigned long)result;
94936   return jresult;
94937 }
94938
94939
94940 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_capacity(void * jarg1) {
94941   unsigned long jresult ;
94942   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94943   std::vector< Dali::Actor >::size_type result;
94944
94945   arg1 = (std::vector< Dali::Actor > *)jarg1;
94946   {
94947     try {
94948       result = ((std::vector< Dali::Actor > const *)arg1)->capacity();
94949     } catch (std::out_of_range& e) {
94950       {
94951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94952       };
94953     } catch (std::exception& e) {
94954       {
94955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94956       };
94957     } catch (Dali::DaliException e) {
94958       {
94959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94960       };
94961     } catch (...) {
94962       {
94963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94964       };
94965     }
94966   }
94967
94968   jresult = (unsigned long)result;
94969   return jresult;
94970 }
94971
94972
94973 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_reserve(void * jarg1, unsigned long jarg2) {
94974   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94975   std::vector< Dali::Actor >::size_type arg2 ;
94976
94977   arg1 = (std::vector< Dali::Actor > *)jarg1;
94978   arg2 = (std::vector< Dali::Actor >::size_type)jarg2;
94979   {
94980     try {
94981       (arg1)->reserve(arg2);
94982     } catch (std::out_of_range& e) {
94983       {
94984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94985       };
94986     } catch (std::exception& e) {
94987       {
94988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94989       };
94990     } catch (Dali::DaliException e) {
94991       {
94992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94993       };
94994     } catch (...) {
94995       {
94996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94997       };
94998     }
94999   }
95000
95001 }
95002
95003
95004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_0() {
95005   void * jresult ;
95006   std::vector< Dali::Actor > *result = 0 ;
95007
95008   {
95009     try {
95010       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >();
95011     } catch (std::out_of_range& e) {
95012       {
95013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95014       };
95015     } catch (std::exception& e) {
95016       {
95017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95018       };
95019     } catch (Dali::DaliException e) {
95020       {
95021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95022       };
95023     } catch (...) {
95024       {
95025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95026       };
95027     }
95028   }
95029
95030   jresult = (void *)result;
95031   return jresult;
95032 }
95033
95034
95035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_1(void * jarg1) {
95036   void * jresult ;
95037   std::vector< Dali::Actor > *arg1 = 0 ;
95038   std::vector< Dali::Actor > *result = 0 ;
95039
95040   arg1 = (std::vector< Dali::Actor > *)jarg1;
95041   if (!arg1) {
95042     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
95043     return 0;
95044   }
95045   {
95046     try {
95047       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >((std::vector< Dali::Actor > const &)*arg1);
95048     } catch (std::out_of_range& e) {
95049       {
95050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95051       };
95052     } catch (std::exception& e) {
95053       {
95054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95055       };
95056     } catch (Dali::DaliException e) {
95057       {
95058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95059       };
95060     } catch (...) {
95061       {
95062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95063       };
95064     }
95065   }
95066
95067   jresult = (void *)result;
95068   return jresult;
95069 }
95070
95071
95072 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_2(int jarg1) {
95073   void * jresult ;
95074   int arg1 ;
95075   std::vector< Dali::Actor > *result = 0 ;
95076
95077   arg1 = (int)jarg1;
95078   {
95079     try {
95080       try {
95081         result = (std::vector< Dali::Actor > *)new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(arg1);
95082       }
95083       catch(std::out_of_range &_e) {
95084         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95085         return 0;
95086       }
95087
95088     } catch (std::out_of_range& e) {
95089       {
95090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95091       };
95092     } catch (std::exception& e) {
95093       {
95094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95095       };
95096     } catch (Dali::DaliException e) {
95097       {
95098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95099       };
95100     } catch (...) {
95101       {
95102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95103       };
95104     }
95105   }
95106
95107   jresult = (void *)result;
95108   return jresult;
95109 }
95110
95111
95112 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitemcopy(void * jarg1, int jarg2) {
95113   void * jresult ;
95114   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95115   int arg2 ;
95116   Dali::Actor result;
95117
95118   arg1 = (std::vector< Dali::Actor > *)jarg1;
95119   arg2 = (int)jarg2;
95120   {
95121     try {
95122       try {
95123         result = std_vector_Sl_Dali_Actor_Sg__getitemcopy(arg1,arg2);
95124       }
95125       catch(std::out_of_range &_e) {
95126         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95127         return 0;
95128       }
95129
95130     } catch (std::out_of_range& e) {
95131       {
95132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95133       };
95134     } catch (std::exception& e) {
95135       {
95136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95137       };
95138     } catch (Dali::DaliException e) {
95139       {
95140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95141       };
95142     } catch (...) {
95143       {
95144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95145       };
95146     }
95147   }
95148
95149   jresult = new Dali::Actor((const Dali::Actor &)result);
95150   return jresult;
95151 }
95152
95153
95154 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitem(void * jarg1, int jarg2) {
95155   void * jresult ;
95156   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95157   int arg2 ;
95158   Dali::Actor *result = 0 ;
95159
95160   arg1 = (std::vector< Dali::Actor > *)jarg1;
95161   arg2 = (int)jarg2;
95162   {
95163     try {
95164       try {
95165         result = (Dali::Actor *) &std_vector_Sl_Dali_Actor_Sg__getitem(arg1,arg2);
95166       }
95167       catch(std::out_of_range &_e) {
95168         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95169         return 0;
95170       }
95171
95172     } catch (std::out_of_range& e) {
95173       {
95174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95175       };
95176     } catch (std::exception& e) {
95177       {
95178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95179       };
95180     } catch (Dali::DaliException e) {
95181       {
95182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95183       };
95184     } catch (...) {
95185       {
95186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95187       };
95188     }
95189   }
95190
95191   jresult = (void *)result;
95192   return jresult;
95193 }
95194
95195
95196 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
95197   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95198   int arg2 ;
95199   Dali::Actor *arg3 = 0 ;
95200
95201   arg1 = (std::vector< Dali::Actor > *)jarg1;
95202   arg2 = (int)jarg2;
95203   arg3 = (Dali::Actor *)jarg3;
95204   if (!arg3) {
95205     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
95206     return ;
95207   }
95208   {
95209     try {
95210       try {
95211         std_vector_Sl_Dali_Actor_Sg__setitem(arg1,arg2,(Dali::Actor const &)*arg3);
95212       }
95213       catch(std::out_of_range &_e) {
95214         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95215         return ;
95216       }
95217
95218     } catch (std::out_of_range& e) {
95219       {
95220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95221       };
95222     } catch (std::exception& e) {
95223       {
95224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95225       };
95226     } catch (Dali::DaliException e) {
95227       {
95228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95229       };
95230     } catch (...) {
95231       {
95232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95233       };
95234     }
95235   }
95236
95237 }
95238
95239
95240 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_AddRange(void * jarg1, void * jarg2) {
95241   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95242   std::vector< Dali::Actor > *arg2 = 0 ;
95243
95244   arg1 = (std::vector< Dali::Actor > *)jarg1;
95245   arg2 = (std::vector< Dali::Actor > *)jarg2;
95246   if (!arg2) {
95247     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
95248     return ;
95249   }
95250   {
95251     try {
95252       std_vector_Sl_Dali_Actor_Sg__AddRange(arg1,(std::vector< Dali::Actor > const &)*arg2);
95253     } catch (std::out_of_range& e) {
95254       {
95255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95256       };
95257     } catch (std::exception& e) {
95258       {
95259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95260       };
95261     } catch (Dali::DaliException e) {
95262       {
95263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95264       };
95265     } catch (...) {
95266       {
95267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95268       };
95269     }
95270   }
95271
95272 }
95273
95274
95275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
95276   void * jresult ;
95277   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95278   int arg2 ;
95279   int arg3 ;
95280   std::vector< Dali::Actor > *result = 0 ;
95281
95282   arg1 = (std::vector< Dali::Actor > *)jarg1;
95283   arg2 = (int)jarg2;
95284   arg3 = (int)jarg3;
95285   {
95286     try {
95287       try {
95288         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__GetRange(arg1,arg2,arg3);
95289       }
95290       catch(std::out_of_range &_e) {
95291         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95292         return 0;
95293       }
95294       catch(std::invalid_argument &_e) {
95295         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
95296         return 0;
95297       }
95298
95299     } catch (std::out_of_range& e) {
95300       {
95301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95302       };
95303     } catch (std::exception& e) {
95304       {
95305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95306       };
95307     } catch (Dali::DaliException e) {
95308       {
95309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95310       };
95311     } catch (...) {
95312       {
95313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95314       };
95315     }
95316   }
95317
95318   jresult = (void *)result;
95319   return jresult;
95320 }
95321
95322
95323 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
95324   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95325   int arg2 ;
95326   Dali::Actor *arg3 = 0 ;
95327
95328   arg1 = (std::vector< Dali::Actor > *)jarg1;
95329   arg2 = (int)jarg2;
95330   arg3 = (Dali::Actor *)jarg3;
95331   if (!arg3) {
95332     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
95333     return ;
95334   }
95335   {
95336     try {
95337       try {
95338         std_vector_Sl_Dali_Actor_Sg__Insert(arg1,arg2,(Dali::Actor const &)*arg3);
95339       }
95340       catch(std::out_of_range &_e) {
95341         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95342         return ;
95343       }
95344
95345     } catch (std::out_of_range& e) {
95346       {
95347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95348       };
95349     } catch (std::exception& e) {
95350       {
95351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95352       };
95353     } catch (Dali::DaliException e) {
95354       {
95355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95356       };
95357     } catch (...) {
95358       {
95359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95360       };
95361     }
95362   }
95363
95364 }
95365
95366
95367 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
95368   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95369   int arg2 ;
95370   std::vector< Dali::Actor > *arg3 = 0 ;
95371
95372   arg1 = (std::vector< Dali::Actor > *)jarg1;
95373   arg2 = (int)jarg2;
95374   arg3 = (std::vector< Dali::Actor > *)jarg3;
95375   if (!arg3) {
95376     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
95377     return ;
95378   }
95379   {
95380     try {
95381       try {
95382         std_vector_Sl_Dali_Actor_Sg__InsertRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
95383       }
95384       catch(std::out_of_range &_e) {
95385         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95386         return ;
95387       }
95388
95389     } catch (std::out_of_range& e) {
95390       {
95391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95392       };
95393     } catch (std::exception& e) {
95394       {
95395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95396       };
95397     } catch (Dali::DaliException e) {
95398       {
95399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95400       };
95401     } catch (...) {
95402       {
95403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95404       };
95405     }
95406   }
95407
95408 }
95409
95410
95411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveAt(void * jarg1, int jarg2) {
95412   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95413   int arg2 ;
95414
95415   arg1 = (std::vector< Dali::Actor > *)jarg1;
95416   arg2 = (int)jarg2;
95417   {
95418     try {
95419       try {
95420         std_vector_Sl_Dali_Actor_Sg__RemoveAt(arg1,arg2);
95421       }
95422       catch(std::out_of_range &_e) {
95423         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95424         return ;
95425       }
95426
95427     } catch (std::out_of_range& e) {
95428       {
95429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95430       };
95431     } catch (std::exception& e) {
95432       {
95433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95434       };
95435     } catch (Dali::DaliException e) {
95436       {
95437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95438       };
95439     } catch (...) {
95440       {
95441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95442       };
95443     }
95444   }
95445
95446 }
95447
95448
95449 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
95450   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95451   int arg2 ;
95452   int arg3 ;
95453
95454   arg1 = (std::vector< Dali::Actor > *)jarg1;
95455   arg2 = (int)jarg2;
95456   arg3 = (int)jarg3;
95457   {
95458     try {
95459       try {
95460         std_vector_Sl_Dali_Actor_Sg__RemoveRange(arg1,arg2,arg3);
95461       }
95462       catch(std::out_of_range &_e) {
95463         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95464         return ;
95465       }
95466       catch(std::invalid_argument &_e) {
95467         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
95468         return ;
95469       }
95470
95471     } catch (std::out_of_range& e) {
95472       {
95473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95474       };
95475     } catch (std::exception& e) {
95476       {
95477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95478       };
95479     } catch (Dali::DaliException e) {
95480       {
95481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95482       };
95483     } catch (...) {
95484       {
95485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95486       };
95487     }
95488   }
95489
95490 }
95491
95492
95493 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_Repeat(void * jarg1, int jarg2) {
95494   void * jresult ;
95495   Dali::Actor *arg1 = 0 ;
95496   int arg2 ;
95497   std::vector< Dali::Actor > *result = 0 ;
95498
95499   arg1 = (Dali::Actor *)jarg1;
95500   if (!arg1) {
95501     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
95502     return 0;
95503   }
95504   arg2 = (int)jarg2;
95505   {
95506     try {
95507       try {
95508         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__Repeat((Dali::Actor const &)*arg1,arg2);
95509       }
95510       catch(std::out_of_range &_e) {
95511         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95512         return 0;
95513       }
95514
95515     } catch (std::out_of_range& e) {
95516       {
95517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95518       };
95519     } catch (std::exception& e) {
95520       {
95521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95522       };
95523     } catch (Dali::DaliException e) {
95524       {
95525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95526       };
95527     } catch (...) {
95528       {
95529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95530       };
95531     }
95532   }
95533
95534   jresult = (void *)result;
95535   return jresult;
95536 }
95537
95538
95539 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_0(void * jarg1) {
95540   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95541
95542   arg1 = (std::vector< Dali::Actor > *)jarg1;
95543   {
95544     try {
95545       std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(arg1);
95546     } catch (std::out_of_range& e) {
95547       {
95548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95549       };
95550     } catch (std::exception& e) {
95551       {
95552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95553       };
95554     } catch (Dali::DaliException e) {
95555       {
95556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95557       };
95558     } catch (...) {
95559       {
95560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95561       };
95562     }
95563   }
95564
95565 }
95566
95567
95568 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
95569   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95570   int arg2 ;
95571   int arg3 ;
95572
95573   arg1 = (std::vector< Dali::Actor > *)jarg1;
95574   arg2 = (int)jarg2;
95575   arg3 = (int)jarg3;
95576   {
95577     try {
95578       try {
95579         std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
95580       }
95581       catch(std::out_of_range &_e) {
95582         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95583         return ;
95584       }
95585       catch(std::invalid_argument &_e) {
95586         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
95587         return ;
95588       }
95589
95590     } catch (std::out_of_range& e) {
95591       {
95592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95593       };
95594     } catch (std::exception& e) {
95595       {
95596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95597       };
95598     } catch (Dali::DaliException e) {
95599       {
95600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95601       };
95602     } catch (...) {
95603       {
95604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95605       };
95606     }
95607   }
95608
95609 }
95610
95611
95612 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
95613   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95614   int arg2 ;
95615   std::vector< Dali::Actor > *arg3 = 0 ;
95616
95617   arg1 = (std::vector< Dali::Actor > *)jarg1;
95618   arg2 = (int)jarg2;
95619   arg3 = (std::vector< Dali::Actor > *)jarg3;
95620   if (!arg3) {
95621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
95622     return ;
95623   }
95624   {
95625     try {
95626       try {
95627         std_vector_Sl_Dali_Actor_Sg__SetRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
95628       }
95629       catch(std::out_of_range &_e) {
95630         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95631         return ;
95632       }
95633
95634     } catch (std::out_of_range& e) {
95635       {
95636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95637       };
95638     } catch (std::exception& e) {
95639       {
95640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95641       };
95642     } catch (Dali::DaliException e) {
95643       {
95644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95645       };
95646     } catch (...) {
95647       {
95648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95649       };
95650     }
95651   }
95652
95653 }
95654
95655
95656 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorContainer(void * jarg1) {
95657   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95658
95659   arg1 = (std::vector< Dali::Actor > *)jarg1;
95660   {
95661     try {
95662       delete arg1;
95663     } catch (std::out_of_range& e) {
95664       {
95665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95666       };
95667     } catch (std::exception& e) {
95668       {
95669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95670       };
95671     } catch (Dali::DaliException e) {
95672       {
95673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95674       };
95675     } catch (...) {
95676       {
95677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95678       };
95679     }
95680   }
95681
95682 }
95683
95684
95685 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Empty(void * jarg1) {
95686   unsigned int jresult ;
95687   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95688   bool result;
95689
95690   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95691   {
95692     try {
95693       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
95694     } catch (std::out_of_range& e) {
95695       {
95696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95697       };
95698     } catch (std::exception& e) {
95699       {
95700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95701       };
95702     } catch (Dali::DaliException e) {
95703       {
95704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95705       };
95706     } catch (...) {
95707       {
95708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95709       };
95710     }
95711   }
95712
95713   jresult = result;
95714   return jresult;
95715 }
95716
95717
95718 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_GetConnectionCount(void * jarg1) {
95719   unsigned long jresult ;
95720   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95721   std::size_t result;
95722
95723   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95724   {
95725     try {
95726       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
95727     } catch (std::out_of_range& e) {
95728       {
95729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95730       };
95731     } catch (std::exception& e) {
95732       {
95733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95734       };
95735     } catch (Dali::DaliException e) {
95736       {
95737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95738       };
95739     } catch (...) {
95740       {
95741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95742       };
95743     }
95744   }
95745
95746   jresult = (unsigned long)result;
95747   return jresult;
95748 }
95749
95750
95751 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Connect(void * jarg1, void * jarg2) {
95752   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95753   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
95754
95755   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95756   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
95757   {
95758     try {
95759       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(arg1,arg2);
95760     } catch (std::out_of_range& e) {
95761       {
95762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95763       };
95764     } catch (std::exception& e) {
95765       {
95766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95767       };
95768     } catch (Dali::DaliException e) {
95769       {
95770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95771       };
95772     } catch (...) {
95773       {
95774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95775       };
95776     }
95777   }
95778
95779 }
95780
95781
95782 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Disconnect(void * jarg1, void * jarg2) {
95783   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95784   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
95785
95786   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95787   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
95788   {
95789     try {
95790       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(arg1,arg2);
95791     } catch (std::out_of_range& e) {
95792       {
95793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95794       };
95795     } catch (std::exception& e) {
95796       {
95797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95798       };
95799     } catch (Dali::DaliException e) {
95800       {
95801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95802       };
95803     } catch (...) {
95804       {
95805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95806       };
95807     }
95808   }
95809
95810 }
95811
95812
95813 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Emit(void * jarg1, void * jarg2) {
95814   unsigned int jresult ;
95815   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95816   Dali::Toolkit::AccessibilityManager *arg2 = 0 ;
95817   bool result;
95818
95819   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95820   arg2 = (Dali::Toolkit::AccessibilityManager *)jarg2;
95821   if (!arg2) {
95822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AccessibilityManager & type is null", 0);
95823     return 0;
95824   }
95825   {
95826     try {
95827       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(arg1,*arg2);
95828     } catch (std::out_of_range& e) {
95829       {
95830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95831       };
95832     } catch (std::exception& e) {
95833       {
95834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95835       };
95836     } catch (Dali::DaliException e) {
95837       {
95838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95839       };
95840     } catch (...) {
95841       {
95842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95843       };
95844     }
95845   }
95846
95847   jresult = result;
95848   return jresult;
95849 }
95850
95851
95852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityActionSignal() {
95853   void * jresult ;
95854   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *result = 0 ;
95855
95856   {
95857     try {
95858       result = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)new Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) >();
95859     } catch (std::out_of_range& e) {
95860       {
95861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95862       };
95863     } catch (std::exception& e) {
95864       {
95865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95866       };
95867     } catch (Dali::DaliException e) {
95868       {
95869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95870       };
95871     } catch (...) {
95872       {
95873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95874       };
95875     }
95876   }
95877
95878   jresult = (void *)result;
95879   return jresult;
95880 }
95881
95882
95883 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityActionSignal(void * jarg1) {
95884   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95885
95886   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95887   {
95888     try {
95889       delete arg1;
95890     } catch (std::out_of_range& e) {
95891       {
95892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95893       };
95894     } catch (std::exception& e) {
95895       {
95896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95897       };
95898     } catch (Dali::DaliException e) {
95899       {
95900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95901       };
95902     } catch (...) {
95903       {
95904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95905       };
95906     }
95907   }
95908
95909 }
95910
95911
95912 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Empty(void * jarg1) {
95913   unsigned int jresult ;
95914   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95915   bool result;
95916
95917   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95918   {
95919     try {
95920       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);
95921     } catch (std::out_of_range& e) {
95922       {
95923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95924       };
95925     } catch (std::exception& e) {
95926       {
95927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95928       };
95929     } catch (Dali::DaliException e) {
95930       {
95931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95932       };
95933     } catch (...) {
95934       {
95935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95936       };
95937     }
95938   }
95939
95940   jresult = result;
95941   return jresult;
95942 }
95943
95944
95945 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_GetConnectionCount(void * jarg1) {
95946   unsigned long jresult ;
95947   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95948   std::size_t result;
95949
95950   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95951   {
95952     try {
95953       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);
95954     } catch (std::out_of_range& e) {
95955       {
95956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95957       };
95958     } catch (std::exception& e) {
95959       {
95960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95961       };
95962     } catch (Dali::DaliException e) {
95963       {
95964         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95965       };
95966     } catch (...) {
95967       {
95968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95969       };
95970     }
95971   }
95972
95973   jresult = (unsigned long)result;
95974   return jresult;
95975 }
95976
95977
95978 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Connect(void * jarg1, void * jarg2) {
95979   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95980   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
95981
95982   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95983   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
95984   {
95985     try {
95986       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(arg1,arg2);
95987     } catch (std::out_of_range& e) {
95988       {
95989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95990       };
95991     } catch (std::exception& e) {
95992       {
95993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95994       };
95995     } catch (Dali::DaliException e) {
95996       {
95997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95998       };
95999     } catch (...) {
96000       {
96001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96002       };
96003     }
96004   }
96005
96006 }
96007
96008
96009 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Disconnect(void * jarg1, void * jarg2) {
96010   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
96011   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
96012
96013   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
96014   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
96015   {
96016     try {
96017       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(arg1,arg2);
96018     } catch (std::out_of_range& e) {
96019       {
96020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96021       };
96022     } catch (std::exception& e) {
96023       {
96024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96025       };
96026     } catch (Dali::DaliException e) {
96027       {
96028         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96029       };
96030     } catch (...) {
96031       {
96032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96033       };
96034     }
96035   }
96036
96037 }
96038
96039
96040 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
96041   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
96042   Dali::Actor arg2 ;
96043   Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg3 ;
96044   Dali::Actor *argp2 ;
96045
96046   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
96047   argp2 = (Dali::Actor *)jarg2;
96048   if (!argp2) {
96049     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
96050     return ;
96051   }
96052   arg2 = *argp2;
96053   arg3 = (Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)jarg3;
96054   {
96055     try {
96056       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(arg1,arg2,arg3);
96057     } catch (std::out_of_range& e) {
96058       {
96059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96060       };
96061     } catch (std::exception& e) {
96062       {
96063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96064       };
96065     } catch (Dali::DaliException e) {
96066       {
96067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96068       };
96069     } catch (...) {
96070       {
96071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96072       };
96073     }
96074   }
96075
96076 }
96077
96078
96079 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityFocusOvershotSignal() {
96080   void * jresult ;
96081   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *result = 0 ;
96082
96083   {
96084     try {
96085       result = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)new Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) >();
96086     } catch (std::out_of_range& e) {
96087       {
96088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96089       };
96090     } catch (std::exception& e) {
96091       {
96092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96093       };
96094     } catch (Dali::DaliException e) {
96095       {
96096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96097       };
96098     } catch (...) {
96099       {
96100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96101       };
96102     }
96103   }
96104
96105   jresult = (void *)result;
96106   return jresult;
96107 }
96108
96109
96110 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityFocusOvershotSignal(void * jarg1) {
96111   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
96112
96113   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
96114   {
96115     try {
96116       delete arg1;
96117     } catch (std::out_of_range& e) {
96118       {
96119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96120       };
96121     } catch (std::exception& e) {
96122       {
96123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96124       };
96125     } catch (Dali::DaliException e) {
96126       {
96127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96128       };
96129     } catch (...) {
96130       {
96131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96132       };
96133     }
96134   }
96135
96136 }
96137
96138
96139 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Empty(void * jarg1) {
96140   unsigned int jresult ;
96141   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
96142   bool result;
96143
96144   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
96145   {
96146     try {
96147       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
96148     } catch (std::out_of_range& e) {
96149       {
96150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96151       };
96152     } catch (std::exception& e) {
96153       {
96154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96155       };
96156     } catch (Dali::DaliException e) {
96157       {
96158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96159       };
96160     } catch (...) {
96161       {
96162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96163       };
96164     }
96165   }
96166
96167   jresult = result;
96168   return jresult;
96169 }
96170
96171
96172 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusChangedSignal_GetConnectionCount(void * jarg1) {
96173   unsigned long jresult ;
96174   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
96175   std::size_t result;
96176
96177   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
96178   {
96179     try {
96180       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
96181     } catch (std::out_of_range& e) {
96182       {
96183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96184       };
96185     } catch (std::exception& e) {
96186       {
96187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96188       };
96189     } catch (Dali::DaliException e) {
96190       {
96191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96192       };
96193     } catch (...) {
96194       {
96195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96196       };
96197     }
96198   }
96199
96200   jresult = (unsigned long)result;
96201   return jresult;
96202 }
96203
96204
96205 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Connect(void * jarg1, void * jarg2) {
96206   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
96207   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
96208
96209   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
96210   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
96211   {
96212     try {
96213       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(arg1,arg2);
96214     } catch (std::out_of_range& e) {
96215       {
96216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96217       };
96218     } catch (std::exception& e) {
96219       {
96220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96221       };
96222     } catch (Dali::DaliException e) {
96223       {
96224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96225       };
96226     } catch (...) {
96227       {
96228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96229       };
96230     }
96231   }
96232
96233 }
96234
96235
96236 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Disconnect(void * jarg1, void * jarg2) {
96237   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
96238   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
96239
96240   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
96241   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
96242   {
96243     try {
96244       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
96245     } catch (std::out_of_range& e) {
96246       {
96247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96248       };
96249     } catch (std::exception& e) {
96250       {
96251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96252       };
96253     } catch (Dali::DaliException e) {
96254       {
96255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96256       };
96257     } catch (...) {
96258       {
96259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96260       };
96261     }
96262   }
96263
96264 }
96265
96266
96267 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
96268   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
96269   Dali::Actor arg2 ;
96270   Dali::Actor arg3 ;
96271   Dali::Actor *argp2 ;
96272   Dali::Actor *argp3 ;
96273
96274   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
96275   argp2 = (Dali::Actor *)jarg2;
96276   if (!argp2) {
96277     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
96278     return ;
96279   }
96280   arg2 = *argp2;
96281   argp3 = (Dali::Actor *)jarg3;
96282   if (!argp3) {
96283     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
96284     return ;
96285   }
96286   arg3 = *argp3;
96287   {
96288     try {
96289       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(arg1,arg2,arg3);
96290     } catch (std::out_of_range& e) {
96291       {
96292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96293       };
96294     } catch (std::exception& e) {
96295       {
96296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96297       };
96298     } catch (Dali::DaliException e) {
96299       {
96300         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96301       };
96302     } catch (...) {
96303       {
96304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96305       };
96306     }
96307   }
96308
96309 }
96310
96311
96312 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusChangedSignal() {
96313   void * jresult ;
96314   Dali::Signal< void (Dali::Actor,Dali::Actor) > *result = 0 ;
96315
96316   {
96317     try {
96318       result = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)new Dali::Signal< void (Dali::Actor,Dali::Actor) >();
96319     } catch (std::out_of_range& e) {
96320       {
96321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96322       };
96323     } catch (std::exception& e) {
96324       {
96325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96326       };
96327     } catch (Dali::DaliException e) {
96328       {
96329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96330       };
96331     } catch (...) {
96332       {
96333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96334       };
96335     }
96336   }
96337
96338   jresult = (void *)result;
96339   return jresult;
96340 }
96341
96342
96343 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusChangedSignal(void * jarg1) {
96344   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
96345
96346   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
96347   {
96348     try {
96349       delete arg1;
96350     } catch (std::out_of_range& e) {
96351       {
96352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96353       };
96354     } catch (std::exception& e) {
96355       {
96356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96357       };
96358     } catch (Dali::DaliException e) {
96359       {
96360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96361       };
96362     } catch (...) {
96363       {
96364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96365       };
96366     }
96367   }
96368
96369 }
96370
96371
96372 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Empty(void * jarg1) {
96373   unsigned int jresult ;
96374   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96375   bool result;
96376
96377   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96378   {
96379     try {
96380       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
96381     } catch (std::out_of_range& e) {
96382       {
96383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96384       };
96385     } catch (std::exception& e) {
96386       {
96387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96388       };
96389     } catch (Dali::DaliException e) {
96390       {
96391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96392       };
96393     } catch (...) {
96394       {
96395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96396       };
96397     }
96398   }
96399
96400   jresult = result;
96401   return jresult;
96402 }
96403
96404
96405 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_GetConnectionCount(void * jarg1) {
96406   unsigned long jresult ;
96407   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96408   std::size_t result;
96409
96410   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96411   {
96412     try {
96413       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
96414     } catch (std::out_of_range& e) {
96415       {
96416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96417       };
96418     } catch (std::exception& e) {
96419       {
96420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96421       };
96422     } catch (Dali::DaliException e) {
96423       {
96424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96425       };
96426     } catch (...) {
96427       {
96428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96429       };
96430     }
96431   }
96432
96433   jresult = (unsigned long)result;
96434   return jresult;
96435 }
96436
96437
96438 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Connect(void * jarg1, void * jarg2) {
96439   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96440   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
96441
96442   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96443   arg2 = (void (*)(Dali::Actor,bool))jarg2;
96444   {
96445     try {
96446       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(arg1,arg2);
96447     } catch (std::out_of_range& e) {
96448       {
96449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96450       };
96451     } catch (std::exception& e) {
96452       {
96453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96454       };
96455     } catch (Dali::DaliException e) {
96456       {
96457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96458       };
96459     } catch (...) {
96460       {
96461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96462       };
96463     }
96464   }
96465
96466 }
96467
96468
96469 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Disconnect(void * jarg1, void * jarg2) {
96470   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96471   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
96472
96473   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96474   arg2 = (void (*)(Dali::Actor,bool))jarg2;
96475   {
96476     try {
96477       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
96478     } catch (std::out_of_range& e) {
96479       {
96480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96481       };
96482     } catch (std::exception& e) {
96483       {
96484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96485       };
96486     } catch (Dali::DaliException e) {
96487       {
96488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96489       };
96490     } catch (...) {
96491       {
96492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96493       };
96494     }
96495   }
96496
96497 }
96498
96499
96500 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3) {
96501   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96502   Dali::Actor arg2 ;
96503   bool arg3 ;
96504   Dali::Actor *argp2 ;
96505
96506   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96507   argp2 = (Dali::Actor *)jarg2;
96508   if (!argp2) {
96509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
96510     return ;
96511   }
96512   arg2 = *argp2;
96513   arg3 = jarg3 ? true : false;
96514   {
96515     try {
96516       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3);
96517     } catch (std::out_of_range& e) {
96518       {
96519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96520       };
96521     } catch (std::exception& e) {
96522       {
96523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96524       };
96525     } catch (Dali::DaliException e) {
96526       {
96527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96528       };
96529     } catch (...) {
96530       {
96531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96532       };
96533     }
96534   }
96535
96536 }
96537
96538
96539 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusGroupChangedSignal() {
96540   void * jresult ;
96541   Dali::Signal< void (Dali::Actor,bool) > *result = 0 ;
96542
96543   {
96544     try {
96545       result = (Dali::Signal< void (Dali::Actor,bool) > *)new Dali::Signal< void (Dali::Actor,bool) >();
96546     } catch (std::out_of_range& e) {
96547       {
96548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96549       };
96550     } catch (std::exception& e) {
96551       {
96552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96553       };
96554     } catch (Dali::DaliException e) {
96555       {
96556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96557       };
96558     } catch (...) {
96559       {
96560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96561       };
96562     }
96563   }
96564
96565   jresult = (void *)result;
96566   return jresult;
96567 }
96568
96569
96570 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusGroupChangedSignal(void * jarg1) {
96571   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96572
96573   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96574   {
96575     try {
96576       delete arg1;
96577     } catch (std::out_of_range& e) {
96578       {
96579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96580       };
96581     } catch (std::exception& e) {
96582       {
96583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96584       };
96585     } catch (Dali::DaliException e) {
96586       {
96587         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96588       };
96589     } catch (...) {
96590       {
96591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96592       };
96593     }
96594   }
96595
96596 }
96597
96598
96599 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Empty(void * jarg1) {
96600   unsigned int jresult ;
96601   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96602   bool result;
96603
96604   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96605   {
96606     try {
96607       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);
96608     } catch (std::out_of_range& e) {
96609       {
96610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96611       };
96612     } catch (std::exception& e) {
96613       {
96614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96615       };
96616     } catch (Dali::DaliException e) {
96617       {
96618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96619       };
96620     } catch (...) {
96621       {
96622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96623       };
96624     }
96625   }
96626
96627   jresult = result;
96628   return jresult;
96629 }
96630
96631
96632 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StyleChangedSignal_GetConnectionCount(void * jarg1) {
96633   unsigned long jresult ;
96634   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96635   std::size_t result;
96636
96637   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96638   {
96639     try {
96640       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);
96641     } catch (std::out_of_range& e) {
96642       {
96643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96644       };
96645     } catch (std::exception& e) {
96646       {
96647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96648       };
96649     } catch (Dali::DaliException e) {
96650       {
96651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96652       };
96653     } catch (...) {
96654       {
96655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96656       };
96657     }
96658   }
96659
96660   jresult = (unsigned long)result;
96661   return jresult;
96662 }
96663
96664
96665 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Connect(void * jarg1, void * jarg2) {
96666   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96667   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
96668
96669   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96670   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
96671   {
96672     try {
96673       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(arg1,arg2);
96674     } catch (std::out_of_range& e) {
96675       {
96676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96677       };
96678     } catch (std::exception& e) {
96679       {
96680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96681       };
96682     } catch (Dali::DaliException e) {
96683       {
96684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96685       };
96686     } catch (...) {
96687       {
96688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96689       };
96690     }
96691   }
96692
96693 }
96694
96695
96696 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Disconnect(void * jarg1, void * jarg2) {
96697   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96698   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
96699
96700   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96701   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
96702   {
96703     try {
96704       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(arg1,arg2);
96705     } catch (std::out_of_range& e) {
96706       {
96707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96708       };
96709     } catch (std::exception& e) {
96710       {
96711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96712       };
96713     } catch (Dali::DaliException e) {
96714       {
96715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96716       };
96717     } catch (...) {
96718       {
96719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96720       };
96721     }
96722   }
96723
96724 }
96725
96726
96727 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
96728   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96729   Dali::Toolkit::StyleManager arg2 ;
96730   Dali::StyleChange::Type arg3 ;
96731   Dali::Toolkit::StyleManager *argp2 ;
96732
96733   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96734   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
96735   if (!argp2) {
96736     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
96737     return ;
96738   }
96739   arg2 = *argp2;
96740   arg3 = (Dali::StyleChange::Type)jarg3;
96741   {
96742     try {
96743       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(arg1,arg2,arg3);
96744     } catch (std::out_of_range& e) {
96745       {
96746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96747       };
96748     } catch (std::exception& e) {
96749       {
96750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96751       };
96752     } catch (Dali::DaliException e) {
96753       {
96754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96755       };
96756     } catch (...) {
96757       {
96758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96759       };
96760     }
96761   }
96762
96763 }
96764
96765
96766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleChangedSignal() {
96767   void * jresult ;
96768   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *result = 0 ;
96769
96770   {
96771     try {
96772       result = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)new Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) >();
96773     } catch (std::out_of_range& e) {
96774       {
96775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96776       };
96777     } catch (std::exception& e) {
96778       {
96779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96780       };
96781     } catch (Dali::DaliException e) {
96782       {
96783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96784       };
96785     } catch (...) {
96786       {
96787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96788       };
96789     }
96790   }
96791
96792   jresult = (void *)result;
96793   return jresult;
96794 }
96795
96796
96797 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleChangedSignal(void * jarg1) {
96798   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96799
96800   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96801   {
96802     try {
96803       delete arg1;
96804     } catch (std::out_of_range& e) {
96805       {
96806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96807       };
96808     } catch (std::exception& e) {
96809       {
96810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96811       };
96812     } catch (Dali::DaliException e) {
96813       {
96814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96815       };
96816     } catch (...) {
96817       {
96818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96819       };
96820     }
96821   }
96822
96823 }
96824
96825
96826 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Empty(void * jarg1) {
96827   unsigned int jresult ;
96828   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96829   bool result;
96830
96831   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96832   {
96833     try {
96834       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
96835     } catch (std::out_of_range& e) {
96836       {
96837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96838       };
96839     } catch (std::exception& e) {
96840       {
96841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96842       };
96843     } catch (Dali::DaliException e) {
96844       {
96845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96846       };
96847     } catch (...) {
96848       {
96849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96850       };
96851     }
96852   }
96853
96854   jresult = result;
96855   return jresult;
96856 }
96857
96858
96859 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ButtonSignal_GetConnectionCount(void * jarg1) {
96860   unsigned long jresult ;
96861   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96862   std::size_t result;
96863
96864   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96865   {
96866     try {
96867       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
96868     } catch (std::out_of_range& e) {
96869       {
96870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96871       };
96872     } catch (std::exception& e) {
96873       {
96874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96875       };
96876     } catch (Dali::DaliException e) {
96877       {
96878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96879       };
96880     } catch (...) {
96881       {
96882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96883       };
96884     }
96885   }
96886
96887   jresult = (unsigned long)result;
96888   return jresult;
96889 }
96890
96891
96892 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Connect(void * jarg1, void * jarg2) {
96893   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96894   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
96895
96896   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96897   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
96898   {
96899     try {
96900       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(arg1,arg2);
96901     } catch (std::out_of_range& e) {
96902       {
96903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96904       };
96905     } catch (std::exception& e) {
96906       {
96907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96908       };
96909     } catch (Dali::DaliException e) {
96910       {
96911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96912       };
96913     } catch (...) {
96914       {
96915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96916       };
96917     }
96918   }
96919
96920 }
96921
96922
96923 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Disconnect(void * jarg1, void * jarg2) {
96924   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96925   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
96926
96927   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96928   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
96929   {
96930     try {
96931       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(arg1,arg2);
96932     } catch (std::out_of_range& e) {
96933       {
96934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96935       };
96936     } catch (std::exception& e) {
96937       {
96938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96939       };
96940     } catch (Dali::DaliException e) {
96941       {
96942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96943       };
96944     } catch (...) {
96945       {
96946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96947       };
96948     }
96949   }
96950
96951 }
96952
96953
96954 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Emit(void * jarg1, void * jarg2) {
96955   unsigned int jresult ;
96956   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96957   Dali::Toolkit::Button arg2 ;
96958   Dali::Toolkit::Button *argp2 ;
96959   bool result;
96960
96961   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96962   argp2 = (Dali::Toolkit::Button *)jarg2;
96963   if (!argp2) {
96964     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Button", 0);
96965     return 0;
96966   }
96967   arg2 = *argp2;
96968   {
96969     try {
96970       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(arg1,arg2);
96971     } catch (std::out_of_range& e) {
96972       {
96973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96974       };
96975     } catch (std::exception& e) {
96976       {
96977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96978       };
96979     } catch (Dali::DaliException e) {
96980       {
96981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96982       };
96983     } catch (...) {
96984       {
96985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96986       };
96987     }
96988   }
96989
96990   jresult = result;
96991   return jresult;
96992 }
96993
96994
96995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ButtonSignal() {
96996   void * jresult ;
96997   Dali::Signal< bool (Dali::Toolkit::Button) > *result = 0 ;
96998
96999   {
97000     try {
97001       result = (Dali::Signal< bool (Dali::Toolkit::Button) > *)new Dali::Signal< bool (Dali::Toolkit::Button) >();
97002     } catch (std::out_of_range& e) {
97003       {
97004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97005       };
97006     } catch (std::exception& e) {
97007       {
97008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97009       };
97010     } catch (Dali::DaliException e) {
97011       {
97012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97013       };
97014     } catch (...) {
97015       {
97016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97017       };
97018     }
97019   }
97020
97021   jresult = (void *)result;
97022   return jresult;
97023 }
97024
97025
97026 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ButtonSignal(void * jarg1) {
97027   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
97028
97029   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
97030   {
97031     try {
97032       delete arg1;
97033     } catch (std::out_of_range& e) {
97034       {
97035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97036       };
97037     } catch (std::exception& e) {
97038       {
97039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97040       };
97041     } catch (Dali::DaliException e) {
97042       {
97043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97044       };
97045     } catch (...) {
97046       {
97047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97048       };
97049     }
97050   }
97051
97052 }
97053
97054
97055 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Empty(void * jarg1) {
97056   unsigned int jresult ;
97057   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
97058   bool result;
97059
97060   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
97061   {
97062     try {
97063       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
97064     } catch (std::out_of_range& e) {
97065       {
97066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97067       };
97068     } catch (std::exception& e) {
97069       {
97070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97071       };
97072     } catch (Dali::DaliException e) {
97073       {
97074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97075       };
97076     } catch (...) {
97077       {
97078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97079       };
97080     }
97081   }
97082
97083   jresult = result;
97084   return jresult;
97085 }
97086
97087
97088 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_GetConnectionCount(void * jarg1) {
97089   unsigned long jresult ;
97090   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
97091   std::size_t result;
97092
97093   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
97094   {
97095     try {
97096       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
97097     } catch (std::out_of_range& e) {
97098       {
97099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97100       };
97101     } catch (std::exception& e) {
97102       {
97103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97104       };
97105     } catch (Dali::DaliException e) {
97106       {
97107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97108       };
97109     } catch (...) {
97110       {
97111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97112       };
97113     }
97114   }
97115
97116   jresult = (unsigned long)result;
97117   return jresult;
97118 }
97119
97120
97121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Connect(void * jarg1, void * jarg2) {
97122   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
97123   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
97124
97125   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
97126   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
97127   {
97128     try {
97129       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(arg1,arg2);
97130     } catch (std::out_of_range& e) {
97131       {
97132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97133       };
97134     } catch (std::exception& e) {
97135       {
97136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97137       };
97138     } catch (Dali::DaliException e) {
97139       {
97140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97141       };
97142     } catch (...) {
97143       {
97144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97145       };
97146     }
97147   }
97148
97149 }
97150
97151
97152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Disconnect(void * jarg1, void * jarg2) {
97153   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
97154   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
97155
97156   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
97157   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
97158   {
97159     try {
97160       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(arg1,arg2);
97161     } catch (std::out_of_range& e) {
97162       {
97163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97164       };
97165     } catch (std::exception& e) {
97166       {
97167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97168       };
97169     } catch (Dali::DaliException e) {
97170       {
97171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97172       };
97173     } catch (...) {
97174       {
97175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97176       };
97177     }
97178   }
97179
97180 }
97181
97182
97183 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Emit(void * jarg1, void * jarg2) {
97184   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
97185   Dali::Toolkit::GaussianBlurView arg2 ;
97186   Dali::Toolkit::GaussianBlurView *argp2 ;
97187
97188   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
97189   argp2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
97190   if (!argp2) {
97191     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::GaussianBlurView", 0);
97192     return ;
97193   }
97194   arg2 = *argp2;
97195   {
97196     try {
97197       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(arg1,arg2);
97198     } catch (std::out_of_range& e) {
97199       {
97200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97201       };
97202     } catch (std::exception& e) {
97203       {
97204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97205       };
97206     } catch (Dali::DaliException e) {
97207       {
97208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97209       };
97210     } catch (...) {
97211       {
97212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97213       };
97214     }
97215   }
97216
97217 }
97218
97219
97220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurViewSignal() {
97221   void * jresult ;
97222   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *result = 0 ;
97223
97224   {
97225     try {
97226       result = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)new Dali::Signal< void (Dali::Toolkit::GaussianBlurView) >();
97227     } catch (std::out_of_range& e) {
97228       {
97229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97230       };
97231     } catch (std::exception& e) {
97232       {
97233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97234       };
97235     } catch (Dali::DaliException e) {
97236       {
97237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97238       };
97239     } catch (...) {
97240       {
97241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97242       };
97243     }
97244   }
97245
97246   jresult = (void *)result;
97247   return jresult;
97248 }
97249
97250
97251 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurViewSignal(void * jarg1) {
97252   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
97253
97254   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
97255   {
97256     try {
97257       delete arg1;
97258     } catch (std::out_of_range& e) {
97259       {
97260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97261       };
97262     } catch (std::exception& e) {
97263       {
97264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97265       };
97266     } catch (Dali::DaliException e) {
97267       {
97268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97269       };
97270     } catch (...) {
97271       {
97272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97273       };
97274     }
97275   }
97276
97277 }
97278
97279
97280 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageTurnSignal_Empty(void * jarg1) {
97281   unsigned int jresult ;
97282   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
97283   bool result;
97284
97285   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
97286   {
97287     try {
97288       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);
97289     } catch (std::out_of_range& e) {
97290       {
97291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97292       };
97293     } catch (std::exception& e) {
97294       {
97295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97296       };
97297     } catch (Dali::DaliException e) {
97298       {
97299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97300       };
97301     } catch (...) {
97302       {
97303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97304       };
97305     }
97306   }
97307
97308   jresult = result;
97309   return jresult;
97310 }
97311
97312
97313 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PageTurnSignal_GetConnectionCount(void * jarg1) {
97314   unsigned long jresult ;
97315   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
97316   std::size_t result;
97317
97318   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
97319   {
97320     try {
97321       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);
97322     } catch (std::out_of_range& e) {
97323       {
97324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97325       };
97326     } catch (std::exception& e) {
97327       {
97328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97329       };
97330     } catch (Dali::DaliException e) {
97331       {
97332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97333       };
97334     } catch (...) {
97335       {
97336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97337       };
97338     }
97339   }
97340
97341   jresult = (unsigned long)result;
97342   return jresult;
97343 }
97344
97345
97346 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Connect(void * jarg1, void * jarg2) {
97347   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
97348   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
97349
97350   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
97351   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
97352   {
97353     try {
97354       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(arg1,arg2);
97355     } catch (std::out_of_range& e) {
97356       {
97357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97358       };
97359     } catch (std::exception& e) {
97360       {
97361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97362       };
97363     } catch (Dali::DaliException e) {
97364       {
97365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97366       };
97367     } catch (...) {
97368       {
97369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97370       };
97371     }
97372   }
97373
97374 }
97375
97376
97377 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Disconnect(void * jarg1, void * jarg2) {
97378   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
97379   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
97380
97381   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
97382   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
97383   {
97384     try {
97385       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
97386     } catch (std::out_of_range& e) {
97387       {
97388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97389       };
97390     } catch (std::exception& e) {
97391       {
97392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97393       };
97394     } catch (Dali::DaliException e) {
97395       {
97396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97397       };
97398     } catch (...) {
97399       {
97400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97401       };
97402     }
97403   }
97404
97405 }
97406
97407
97408 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
97409   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
97410   Dali::Toolkit::PageTurnView arg2 ;
97411   unsigned int arg3 ;
97412   bool arg4 ;
97413   Dali::Toolkit::PageTurnView *argp2 ;
97414
97415   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
97416   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
97417   if (!argp2) {
97418     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
97419     return ;
97420   }
97421   arg2 = *argp2;
97422   arg3 = (unsigned int)jarg3;
97423   arg4 = jarg4 ? true : false;
97424   {
97425     try {
97426       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3,arg4);
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 void * SWIGSTDCALL CSharp_Dali_new_PageTurnSignal() {
97450   void * jresult ;
97451   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *result = 0 ;
97452
97453   {
97454     try {
97455       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) >();
97456     } catch (std::out_of_range& e) {
97457       {
97458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97459       };
97460     } catch (std::exception& e) {
97461       {
97462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97463       };
97464     } catch (Dali::DaliException e) {
97465       {
97466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97467       };
97468     } catch (...) {
97469       {
97470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97471       };
97472     }
97473   }
97474
97475   jresult = (void *)result;
97476   return jresult;
97477 }
97478
97479
97480 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnSignal(void * jarg1) {
97481   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
97482
97483   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
97484   {
97485     try {
97486       delete arg1;
97487     } catch (std::out_of_range& e) {
97488       {
97489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97490       };
97491     } catch (std::exception& e) {
97492       {
97493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97494       };
97495     } catch (Dali::DaliException e) {
97496       {
97497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97498       };
97499     } catch (...) {
97500       {
97501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97502       };
97503     }
97504   }
97505
97506 }
97507
97508
97509 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PagePanSignal_Empty(void * jarg1) {
97510   unsigned int jresult ;
97511   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97512   bool result;
97513
97514   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97515   {
97516     try {
97517       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
97518     } catch (std::out_of_range& e) {
97519       {
97520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97521       };
97522     } catch (std::exception& e) {
97523       {
97524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97525       };
97526     } catch (Dali::DaliException e) {
97527       {
97528         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97529       };
97530     } catch (...) {
97531       {
97532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97533       };
97534     }
97535   }
97536
97537   jresult = result;
97538   return jresult;
97539 }
97540
97541
97542 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PagePanSignal_GetConnectionCount(void * jarg1) {
97543   unsigned long jresult ;
97544   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97545   std::size_t result;
97546
97547   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97548   {
97549     try {
97550       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
97551     } catch (std::out_of_range& e) {
97552       {
97553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97554       };
97555     } catch (std::exception& e) {
97556       {
97557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97558       };
97559     } catch (Dali::DaliException e) {
97560       {
97561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97562       };
97563     } catch (...) {
97564       {
97565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97566       };
97567     }
97568   }
97569
97570   jresult = (unsigned long)result;
97571   return jresult;
97572 }
97573
97574
97575 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Connect(void * jarg1, void * jarg2) {
97576   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97577   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
97578
97579   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97580   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
97581   {
97582     try {
97583       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(arg1,arg2);
97584     } catch (std::out_of_range& e) {
97585       {
97586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97587       };
97588     } catch (std::exception& e) {
97589       {
97590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97591       };
97592     } catch (Dali::DaliException e) {
97593       {
97594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97595       };
97596     } catch (...) {
97597       {
97598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97599       };
97600     }
97601   }
97602
97603 }
97604
97605
97606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Disconnect(void * jarg1, void * jarg2) {
97607   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97608   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
97609
97610   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97611   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
97612   {
97613     try {
97614       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(arg1,arg2);
97615     } catch (std::out_of_range& e) {
97616       {
97617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97618       };
97619     } catch (std::exception& e) {
97620       {
97621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97622       };
97623     } catch (Dali::DaliException e) {
97624       {
97625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97626       };
97627     } catch (...) {
97628       {
97629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97630       };
97631     }
97632   }
97633
97634 }
97635
97636
97637 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Emit(void * jarg1, void * jarg2) {
97638   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97639   Dali::Toolkit::PageTurnView arg2 ;
97640   Dali::Toolkit::PageTurnView *argp2 ;
97641
97642   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97643   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
97644   if (!argp2) {
97645     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
97646     return ;
97647   }
97648   arg2 = *argp2;
97649   {
97650     try {
97651       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(arg1,arg2);
97652     } catch (std::out_of_range& e) {
97653       {
97654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97655       };
97656     } catch (std::exception& e) {
97657       {
97658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97659       };
97660     } catch (Dali::DaliException e) {
97661       {
97662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97663       };
97664     } catch (...) {
97665       {
97666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97667       };
97668     }
97669   }
97670
97671 }
97672
97673
97674 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PagePanSignal() {
97675   void * jresult ;
97676   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *result = 0 ;
97677
97678   {
97679     try {
97680       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView) >();
97681     } catch (std::out_of_range& e) {
97682       {
97683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97684       };
97685     } catch (std::exception& e) {
97686       {
97687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97688       };
97689     } catch (Dali::DaliException e) {
97690       {
97691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97692       };
97693     } catch (...) {
97694       {
97695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97696       };
97697     }
97698   }
97699
97700   jresult = (void *)result;
97701   return jresult;
97702 }
97703
97704
97705 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PagePanSignal(void * jarg1) {
97706   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97707
97708   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97709   {
97710     try {
97711       delete arg1;
97712     } catch (std::out_of_range& e) {
97713       {
97714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97715       };
97716     } catch (std::exception& e) {
97717       {
97718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97719       };
97720     } catch (Dali::DaliException e) {
97721       {
97722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97723       };
97724     } catch (...) {
97725       {
97726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97727       };
97728     }
97729   }
97730
97731 }
97732
97733
97734 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Empty(void * jarg1) {
97735   unsigned int jresult ;
97736   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97737   bool result;
97738
97739   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97740   {
97741     try {
97742       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);
97743     } catch (std::out_of_range& e) {
97744       {
97745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97746       };
97747     } catch (std::exception& e) {
97748       {
97749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97750       };
97751     } catch (Dali::DaliException e) {
97752       {
97753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97754       };
97755     } catch (...) {
97756       {
97757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97758       };
97759     }
97760   }
97761
97762   jresult = result;
97763   return jresult;
97764 }
97765
97766
97767 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_GetConnectionCount(void * jarg1) {
97768   unsigned long jresult ;
97769   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97770   std::size_t result;
97771
97772   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97773   {
97774     try {
97775       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);
97776     } catch (std::out_of_range& e) {
97777       {
97778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97779       };
97780     } catch (std::exception& e) {
97781       {
97782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97783       };
97784     } catch (Dali::DaliException e) {
97785       {
97786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97787       };
97788     } catch (...) {
97789       {
97790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97791       };
97792     }
97793   }
97794
97795   jresult = (unsigned long)result;
97796   return jresult;
97797 }
97798
97799
97800 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Connect(void * jarg1, void * jarg2) {
97801   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97802   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
97803
97804   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97805   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
97806   {
97807     try {
97808       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(arg1,arg2);
97809     } catch (std::out_of_range& e) {
97810       {
97811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97812       };
97813     } catch (std::exception& e) {
97814       {
97815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97816       };
97817     } catch (Dali::DaliException e) {
97818       {
97819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97820       };
97821     } catch (...) {
97822       {
97823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97824       };
97825     }
97826   }
97827
97828 }
97829
97830
97831 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
97832   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97833   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
97834
97835   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97836   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
97837   {
97838     try {
97839       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(arg1,arg2);
97840     } catch (std::out_of_range& e) {
97841       {
97842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97843       };
97844     } catch (std::exception& e) {
97845       {
97846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97847       };
97848     } catch (Dali::DaliException e) {
97849       {
97850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97851       };
97852     } catch (...) {
97853       {
97854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97855       };
97856     }
97857   }
97858
97859 }
97860
97861
97862 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3, float jarg4) {
97863   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97864   Dali::Toolkit::ProgressBar arg2 ;
97865   float arg3 ;
97866   float arg4 ;
97867   Dali::Toolkit::ProgressBar *argp2 ;
97868
97869   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97870   argp2 = (Dali::Toolkit::ProgressBar *)jarg2;
97871   if (!argp2) {
97872     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ProgressBar", 0);
97873     return ;
97874   }
97875   arg2 = *argp2;
97876   arg3 = (float)jarg3;
97877   arg4 = (float)jarg4;
97878   {
97879     try {
97880       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(arg1,arg2,arg3,arg4);
97881     } catch (std::out_of_range& e) {
97882       {
97883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97884       };
97885     } catch (std::exception& e) {
97886       {
97887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97888       };
97889     } catch (Dali::DaliException e) {
97890       {
97891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97892       };
97893     } catch (...) {
97894       {
97895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97896       };
97897     }
97898   }
97899
97900 }
97901
97902
97903 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBarValueChangedSignal() {
97904   void * jresult ;
97905   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *result = 0 ;
97906
97907   {
97908     try {
97909       result = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)new Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) >();
97910     } catch (std::out_of_range& e) {
97911       {
97912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97913       };
97914     } catch (std::exception& e) {
97915       {
97916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97917       };
97918     } catch (Dali::DaliException e) {
97919       {
97920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97921       };
97922     } catch (...) {
97923       {
97924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97925       };
97926     }
97927   }
97928
97929   jresult = (void *)result;
97930   return jresult;
97931 }
97932
97933
97934 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBarValueChangedSignal(void * jarg1) {
97935   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97936
97937   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97938   {
97939     try {
97940       delete arg1;
97941     } catch (std::out_of_range& e) {
97942       {
97943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97944       };
97945     } catch (std::exception& e) {
97946       {
97947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97948       };
97949     } catch (Dali::DaliException e) {
97950       {
97951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97952       };
97953     } catch (...) {
97954       {
97955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97956       };
97957     }
97958   }
97959
97960 }
97961
97962
97963 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Empty(void * jarg1) {
97964   unsigned int jresult ;
97965   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97966   bool result;
97967
97968   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97969   {
97970     try {
97971       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);
97972     } catch (std::out_of_range& e) {
97973       {
97974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97975       };
97976     } catch (std::exception& e) {
97977       {
97978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97979       };
97980     } catch (Dali::DaliException e) {
97981       {
97982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97983       };
97984     } catch (...) {
97985       {
97986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97987       };
97988     }
97989   }
97990
97991   jresult = result;
97992   return jresult;
97993 }
97994
97995
97996 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_GetConnectionCount(void * jarg1) {
97997   unsigned long jresult ;
97998   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97999   std::size_t result;
98000
98001   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
98002   {
98003     try {
98004       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);
98005     } catch (std::out_of_range& e) {
98006       {
98007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98008       };
98009     } catch (std::exception& e) {
98010       {
98011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98012       };
98013     } catch (Dali::DaliException e) {
98014       {
98015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98016       };
98017     } catch (...) {
98018       {
98019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98020       };
98021     }
98022   }
98023
98024   jresult = (unsigned long)result;
98025   return jresult;
98026 }
98027
98028
98029 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Connect(void * jarg1, void * jarg2) {
98030   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
98031   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
98032
98033   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
98034   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
98035   {
98036     try {
98037       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
98038     } catch (std::out_of_range& e) {
98039       {
98040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98041       };
98042     } catch (std::exception& e) {
98043       {
98044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98045       };
98046     } catch (Dali::DaliException e) {
98047       {
98048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98049       };
98050     } catch (...) {
98051       {
98052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98053       };
98054     }
98055   }
98056
98057 }
98058
98059
98060 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Disconnect(void * jarg1, void * jarg2) {
98061   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
98062   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
98063
98064   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
98065   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
98066   {
98067     try {
98068       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
98069     } catch (std::out_of_range& e) {
98070       {
98071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98072       };
98073     } catch (std::exception& e) {
98074       {
98075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98076       };
98077     } catch (Dali::DaliException e) {
98078       {
98079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98080       };
98081     } catch (...) {
98082       {
98083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98084       };
98085     }
98086   }
98087
98088 }
98089
98090
98091 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Emit(void * jarg1, void * jarg2) {
98092   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
98093   Dali::Toolkit::ScrollView::SnapEvent *arg2 = 0 ;
98094
98095   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
98096   arg2 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg2;
98097   if (!arg2) {
98098     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView::SnapEvent const & type is null", 0);
98099     return ;
98100   }
98101   {
98102     try {
98103       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Toolkit::ScrollView::SnapEvent const &)*arg2);
98104     } catch (std::out_of_range& e) {
98105       {
98106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98107       };
98108     } catch (std::exception& e) {
98109       {
98110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98111       };
98112     } catch (Dali::DaliException e) {
98113       {
98114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98115       };
98116     } catch (...) {
98117       {
98118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98119       };
98120     }
98121   }
98122
98123 }
98124
98125
98126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewSnapStartedSignal() {
98127   void * jresult ;
98128   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *result = 0 ;
98129
98130   {
98131     try {
98132       result = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)new Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) >();
98133     } catch (std::out_of_range& e) {
98134       {
98135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98136       };
98137     } catch (std::exception& e) {
98138       {
98139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98140       };
98141     } catch (Dali::DaliException e) {
98142       {
98143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98144       };
98145     } catch (...) {
98146       {
98147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98148       };
98149     }
98150   }
98151
98152   jresult = (void *)result;
98153   return jresult;
98154 }
98155
98156
98157 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewSnapStartedSignal(void * jarg1) {
98158   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
98159
98160   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
98161   {
98162     try {
98163       delete arg1;
98164     } catch (std::out_of_range& e) {
98165       {
98166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98167       };
98168     } catch (std::exception& e) {
98169       {
98170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98171       };
98172     } catch (Dali::DaliException e) {
98173       {
98174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98175       };
98176     } catch (...) {
98177       {
98178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98179       };
98180     }
98181   }
98182
98183 }
98184
98185
98186 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollableSignal_Empty(void * jarg1) {
98187   unsigned int jresult ;
98188   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
98189   bool result;
98190
98191   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
98192   {
98193     try {
98194       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
98195     } catch (std::out_of_range& e) {
98196       {
98197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98198       };
98199     } catch (std::exception& e) {
98200       {
98201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98202       };
98203     } catch (Dali::DaliException e) {
98204       {
98205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98206       };
98207     } catch (...) {
98208       {
98209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98210       };
98211     }
98212   }
98213
98214   jresult = result;
98215   return jresult;
98216 }
98217
98218
98219 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollableSignal_GetConnectionCount(void * jarg1) {
98220   unsigned long jresult ;
98221   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
98222   std::size_t result;
98223
98224   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
98225   {
98226     try {
98227       result = Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
98228     } catch (std::out_of_range& e) {
98229       {
98230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98231       };
98232     } catch (std::exception& e) {
98233       {
98234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98235       };
98236     } catch (Dali::DaliException e) {
98237       {
98238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98239       };
98240     } catch (...) {
98241       {
98242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98243       };
98244     }
98245   }
98246
98247   jresult = (unsigned long)result;
98248   return jresult;
98249 }
98250
98251
98252 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Connect(void * jarg1, void * jarg2) {
98253   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
98254   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
98255
98256   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
98257   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
98258   {
98259     try {
98260       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(arg1,arg2);
98261     } catch (std::out_of_range& e) {
98262       {
98263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98264       };
98265     } catch (std::exception& e) {
98266       {
98267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98268       };
98269     } catch (Dali::DaliException e) {
98270       {
98271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98272       };
98273     } catch (...) {
98274       {
98275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98276       };
98277     }
98278   }
98279
98280 }
98281
98282
98283 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Disconnect(void * jarg1, void * jarg2) {
98284   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
98285   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
98286
98287   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
98288   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
98289   {
98290     try {
98291       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
98292     } catch (std::out_of_range& e) {
98293       {
98294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98295       };
98296     } catch (std::exception& e) {
98297       {
98298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98299       };
98300     } catch (Dali::DaliException e) {
98301       {
98302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98303       };
98304     } catch (...) {
98305       {
98306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98307       };
98308     }
98309   }
98310
98311 }
98312
98313
98314 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Emit(void * jarg1, void * jarg2) {
98315   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
98316   Dali::Vector2 *arg2 = 0 ;
98317
98318   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
98319   arg2 = (Dali::Vector2 *)jarg2;
98320   if (!arg2) {
98321     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
98322     return ;
98323   }
98324   {
98325     try {
98326       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Vector2 const &)*arg2);
98327     } catch (std::out_of_range& e) {
98328       {
98329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98330       };
98331     } catch (std::exception& e) {
98332       {
98333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98334       };
98335     } catch (Dali::DaliException e) {
98336       {
98337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98338       };
98339     } catch (...) {
98340       {
98341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98342       };
98343     }
98344   }
98345
98346 }
98347
98348
98349 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollableSignal() {
98350   void * jresult ;
98351   Dali::Signal< void (Dali::Vector2 const &) > *result = 0 ;
98352
98353   {
98354     try {
98355       result = (Dali::Signal< void (Dali::Vector2 const &) > *)new Dali::Signal< void (Dali::Vector2 const &) >();
98356     } catch (std::out_of_range& e) {
98357       {
98358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98359       };
98360     } catch (std::exception& e) {
98361       {
98362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98363       };
98364     } catch (Dali::DaliException e) {
98365       {
98366         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98367       };
98368     } catch (...) {
98369       {
98370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98371       };
98372     }
98373   }
98374
98375   jresult = (void *)result;
98376   return jresult;
98377 }
98378
98379
98380 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollableSignal(void * jarg1) {
98381   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
98382
98383   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
98384   {
98385     try {
98386       delete arg1;
98387     } catch (std::out_of_range& e) {
98388       {
98389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98390       };
98391     } catch (std::exception& e) {
98392       {
98393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98394       };
98395     } catch (Dali::DaliException e) {
98396       {
98397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98398       };
98399     } catch (...) {
98400       {
98401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98402       };
98403     }
98404   }
98405
98406 }
98407
98408
98409
98410 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Empty(void * jarg1) {
98411   unsigned int jresult ;
98412   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98413   bool result;
98414
98415   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98416   {
98417     try {
98418       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);
98419     } catch (std::out_of_range& e) {
98420       {
98421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98422       };
98423     } catch (std::exception& e) {
98424       {
98425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98426       };
98427     } catch (Dali::DaliException e) {
98428       {
98429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98430       };
98431     } catch (...) {
98432       {
98433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98434       };
98435     }
98436   }
98437
98438   jresult = result;
98439   return jresult;
98440 }
98441
98442
98443 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ControlKeySignal_GetConnectionCount(void * jarg1) {
98444   unsigned long jresult ;
98445   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98446   std::size_t result;
98447
98448   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98449   {
98450     try {
98451       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);
98452     } catch (std::out_of_range& e) {
98453       {
98454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98455       };
98456     } catch (std::exception& e) {
98457       {
98458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98459       };
98460     } catch (Dali::DaliException e) {
98461       {
98462         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98463       };
98464     } catch (...) {
98465       {
98466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98467       };
98468     }
98469   }
98470
98471   jresult = (unsigned long)result;
98472   return jresult;
98473 }
98474
98475
98476 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Connect(void * jarg1, void * jarg2) {
98477   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98478   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
98479
98480   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98481   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
98482   {
98483     try {
98484       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
98485     } catch (std::out_of_range& e) {
98486       {
98487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98488       };
98489     } catch (std::exception& e) {
98490       {
98491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98492       };
98493     } catch (Dali::DaliException e) {
98494       {
98495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98496       };
98497     } catch (...) {
98498       {
98499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98500       };
98501     }
98502   }
98503
98504 }
98505
98506
98507 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Disconnect(void * jarg1, void * jarg2) {
98508   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98509   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
98510
98511   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98512   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
98513   {
98514     try {
98515       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
98516     } catch (std::out_of_range& e) {
98517       {
98518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98519       };
98520     } catch (std::exception& e) {
98521       {
98522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98523       };
98524     } catch (Dali::DaliException e) {
98525       {
98526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98527       };
98528     } catch (...) {
98529       {
98530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98531       };
98532     }
98533   }
98534
98535 }
98536
98537
98538 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
98539   unsigned int jresult ;
98540   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98541   Dali::Toolkit::Control arg2 ;
98542   Dali::KeyEvent *arg3 = 0 ;
98543   Dali::Toolkit::Control *argp2 ;
98544   bool result;
98545
98546   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98547   argp2 = (Dali::Toolkit::Control *)jarg2;
98548   if (!argp2) {
98549     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
98550     return 0;
98551   }
98552   arg2 = *argp2;
98553   arg3 = (Dali::KeyEvent *)jarg3;
98554   if (!arg3) {
98555     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
98556     return 0;
98557   }
98558   {
98559     try {
98560       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);
98561     } catch (std::out_of_range& e) {
98562       {
98563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98564       };
98565     } catch (std::exception& e) {
98566       {
98567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98568       };
98569     } catch (Dali::DaliException e) {
98570       {
98571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98572       };
98573     } catch (...) {
98574       {
98575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98576       };
98577     }
98578   }
98579
98580   jresult = result;
98581   return jresult;
98582 }
98583
98584
98585 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ControlKeySignal() {
98586   void * jresult ;
98587   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *result = 0 ;
98588
98589   {
98590     try {
98591       result = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)new Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) >();
98592     } catch (std::out_of_range& e) {
98593       {
98594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98595       };
98596     } catch (std::exception& e) {
98597       {
98598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98599       };
98600     } catch (Dali::DaliException e) {
98601       {
98602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98603       };
98604     } catch (...) {
98605       {
98606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98607       };
98608     }
98609   }
98610
98611   jresult = (void *)result;
98612   return jresult;
98613 }
98614
98615
98616 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ControlKeySignal(void * jarg1) {
98617   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98618
98619   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98620   {
98621     try {
98622       delete arg1;
98623     } catch (std::out_of_range& e) {
98624       {
98625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98626       };
98627     } catch (std::exception& e) {
98628       {
98629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98630       };
98631     } catch (Dali::DaliException e) {
98632       {
98633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98634       };
98635     } catch (...) {
98636       {
98637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98638       };
98639     }
98640   }
98641
98642 }
98643
98644
98645 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Empty(void * jarg1) {
98646   unsigned int jresult ;
98647   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98648   bool result;
98649
98650   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98651   {
98652     try {
98653       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
98654     } catch (std::out_of_range& e) {
98655       {
98656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98657       };
98658     } catch (std::exception& e) {
98659       {
98660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98661       };
98662     } catch (Dali::DaliException e) {
98663       {
98664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98665       };
98666     } catch (...) {
98667       {
98668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98669       };
98670     }
98671   }
98672
98673   jresult = result;
98674   return jresult;
98675 }
98676
98677
98678 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_GetConnectionCount(void * jarg1) {
98679   unsigned long jresult ;
98680   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98681   std::size_t result;
98682
98683   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98684   {
98685     try {
98686       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
98687     } catch (std::out_of_range& e) {
98688       {
98689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98690       };
98691     } catch (std::exception& e) {
98692       {
98693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98694       };
98695     } catch (Dali::DaliException e) {
98696       {
98697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98698       };
98699     } catch (...) {
98700       {
98701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98702       };
98703     }
98704   }
98705
98706   jresult = (unsigned long)result;
98707   return jresult;
98708 }
98709
98710
98711 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Connect(void * jarg1, void * jarg2) {
98712   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98713   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
98714
98715   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98716   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
98717   {
98718     try {
98719       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
98720     } catch (std::out_of_range& e) {
98721       {
98722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98723       };
98724     } catch (std::exception& e) {
98725       {
98726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98727       };
98728     } catch (Dali::DaliException e) {
98729       {
98730         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98731       };
98732     } catch (...) {
98733       {
98734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98735       };
98736     }
98737   }
98738
98739 }
98740
98741
98742 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Disconnect(void * jarg1, void * jarg2) {
98743   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98744   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
98745
98746   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98747   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
98748   {
98749     try {
98750       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
98751     } catch (std::out_of_range& e) {
98752       {
98753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98754       };
98755     } catch (std::exception& e) {
98756       {
98757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98758       };
98759     } catch (Dali::DaliException e) {
98760       {
98761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98762       };
98763     } catch (...) {
98764       {
98765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98766       };
98767     }
98768   }
98769
98770 }
98771
98772
98773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Emit(void * jarg1, void * jarg2) {
98774   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98775   Dali::Toolkit::Control arg2 ;
98776   Dali::Toolkit::Control *argp2 ;
98777
98778   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98779   argp2 = (Dali::Toolkit::Control *)jarg2;
98780   if (!argp2) {
98781     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
98782     return ;
98783   }
98784   arg2 = *argp2;
98785   {
98786     try {
98787       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
98788     } catch (std::out_of_range& e) {
98789       {
98790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98791       };
98792     } catch (std::exception& e) {
98793       {
98794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98795       };
98796     } catch (Dali::DaliException e) {
98797       {
98798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98799       };
98800     } catch (...) {
98801       {
98802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98803       };
98804     }
98805   }
98806
98807 }
98808
98809
98810 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusSignal() {
98811   void * jresult ;
98812   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
98813
98814   {
98815     try {
98816       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
98817     } catch (std::out_of_range& e) {
98818       {
98819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98820       };
98821     } catch (std::exception& e) {
98822       {
98823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98824       };
98825     } catch (Dali::DaliException e) {
98826       {
98827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98828       };
98829     } catch (...) {
98830       {
98831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98832       };
98833     }
98834   }
98835
98836   jresult = (void *)result;
98837   return jresult;
98838 }
98839
98840
98841 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusSignal(void * jarg1) {
98842   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98843
98844   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98845   {
98846     try {
98847       delete arg1;
98848     } catch (std::out_of_range& e) {
98849       {
98850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98851       };
98852     } catch (std::exception& e) {
98853       {
98854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98855       };
98856     } catch (Dali::DaliException e) {
98857       {
98858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98859       };
98860     } catch (...) {
98861       {
98862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98863       };
98864     }
98865   }
98866
98867 }
98868
98869
98870 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VideoViewSignal_Empty(void * jarg1) {
98871   unsigned int jresult ;
98872   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98873   bool result;
98874
98875   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98876   {
98877     try {
98878       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
98879     } catch (std::out_of_range& e) {
98880       {
98881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98882       };
98883     } catch (std::exception& e) {
98884       {
98885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98886       };
98887     } catch (Dali::DaliException e) {
98888       {
98889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98890       };
98891     } catch (...) {
98892       {
98893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98894       };
98895     }
98896   }
98897
98898   jresult = result;
98899   return jresult;
98900 }
98901
98902
98903 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VideoViewSignal_GetConnectionCount(void * jarg1) {
98904   unsigned long jresult ;
98905   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98906   std::size_t result;
98907
98908   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98909   {
98910     try {
98911       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
98912     } catch (std::out_of_range& e) {
98913       {
98914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98915       };
98916     } catch (std::exception& e) {
98917       {
98918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98919       };
98920     } catch (Dali::DaliException e) {
98921       {
98922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98923       };
98924     } catch (...) {
98925       {
98926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98927       };
98928     }
98929   }
98930
98931   jresult = (unsigned long)result;
98932   return jresult;
98933 }
98934
98935
98936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Connect(void * jarg1, void * jarg2) {
98937   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98938   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
98939
98940   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98941   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
98942   {
98943     try {
98944       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(arg1,arg2);
98945     } catch (std::out_of_range& e) {
98946       {
98947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98948       };
98949     } catch (std::exception& e) {
98950       {
98951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98952       };
98953     } catch (Dali::DaliException e) {
98954       {
98955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98956       };
98957     } catch (...) {
98958       {
98959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98960       };
98961     }
98962   }
98963
98964 }
98965
98966
98967 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Disconnect(void * jarg1, void * jarg2) {
98968   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98969   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
98970
98971   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98972   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
98973   {
98974     try {
98975       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(arg1,arg2);
98976     } catch (std::out_of_range& e) {
98977       {
98978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98979       };
98980     } catch (std::exception& e) {
98981       {
98982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98983       };
98984     } catch (Dali::DaliException e) {
98985       {
98986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98987       };
98988     } catch (...) {
98989       {
98990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98991       };
98992     }
98993   }
98994
98995 }
98996
98997
98998 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Emit(void * jarg1, void * jarg2) {
98999   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
99000   Dali::Toolkit::VideoView *arg2 = 0 ;
99001
99002   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
99003   arg2 = (Dali::Toolkit::VideoView *)jarg2;
99004   if (!arg2) {
99005     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView & type is null", 0);
99006     return ;
99007   }
99008   {
99009     try {
99010       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(arg1,*arg2);
99011     } catch (std::out_of_range& e) {
99012       {
99013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99014       };
99015     } catch (std::exception& e) {
99016       {
99017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99018       };
99019     } catch (Dali::DaliException e) {
99020       {
99021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99022       };
99023     } catch (...) {
99024       {
99025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99026       };
99027     }
99028   }
99029
99030 }
99031
99032
99033 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoViewSignal() {
99034   void * jresult ;
99035   Dali::Signal< void (Dali::Toolkit::VideoView &) > *result = 0 ;
99036
99037   {
99038     try {
99039       result = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)new Dali::Signal< void (Dali::Toolkit::VideoView &) >();
99040     } catch (std::out_of_range& e) {
99041       {
99042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99043       };
99044     } catch (std::exception& e) {
99045       {
99046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99047       };
99048     } catch (Dali::DaliException e) {
99049       {
99050         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99051       };
99052     } catch (...) {
99053       {
99054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99055       };
99056     }
99057   }
99058
99059   jresult = (void *)result;
99060   return jresult;
99061 }
99062
99063
99064 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoViewSignal(void * jarg1) {
99065   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
99066
99067   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
99068   {
99069     try {
99070       delete arg1;
99071     } catch (std::out_of_range& e) {
99072       {
99073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99074       };
99075     } catch (std::exception& e) {
99076       {
99077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99078       };
99079     } catch (Dali::DaliException e) {
99080       {
99081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99082       };
99083     } catch (...) {
99084       {
99085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99086       };
99087     }
99088   }
99089
99090 }
99091
99092
99093 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Empty(void * jarg1) {
99094   unsigned int jresult ;
99095   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
99096   bool result;
99097
99098   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
99099   {
99100     try {
99101       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
99102     } catch (std::out_of_range& e) {
99103       {
99104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99105       };
99106     } catch (std::exception& e) {
99107       {
99108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99109       };
99110     } catch (Dali::DaliException e) {
99111       {
99112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99113       };
99114     } catch (...) {
99115       {
99116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99117       };
99118     }
99119   }
99120
99121   jresult = result;
99122   return jresult;
99123 }
99124
99125
99126 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_GetConnectionCount(void * jarg1) {
99127   unsigned long jresult ;
99128   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
99129   std::size_t result;
99130
99131   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
99132   {
99133     try {
99134       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
99135     } catch (std::out_of_range& e) {
99136       {
99137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99138       };
99139     } catch (std::exception& e) {
99140       {
99141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99142       };
99143     } catch (Dali::DaliException e) {
99144       {
99145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99146       };
99147     } catch (...) {
99148       {
99149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99150       };
99151     }
99152   }
99153
99154   jresult = (unsigned long)result;
99155   return jresult;
99156 }
99157
99158
99159 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Connect(void * jarg1, void * jarg2) {
99160   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
99161   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
99162
99163   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
99164   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
99165   {
99166     try {
99167       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(arg1,arg2);
99168     } catch (std::out_of_range& e) {
99169       {
99170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99171       };
99172     } catch (std::exception& e) {
99173       {
99174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99175       };
99176     } catch (Dali::DaliException e) {
99177       {
99178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99179       };
99180     } catch (...) {
99181       {
99182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99183       };
99184     }
99185   }
99186
99187 }
99188
99189
99190 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
99191   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
99192   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
99193
99194   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
99195   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
99196   {
99197     try {
99198       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(arg1,arg2);
99199     } catch (std::out_of_range& e) {
99200       {
99201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99202       };
99203     } catch (std::exception& e) {
99204       {
99205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99206       };
99207     } catch (Dali::DaliException e) {
99208       {
99209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99210       };
99211     } catch (...) {
99212       {
99213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99214       };
99215     }
99216   }
99217
99218 }
99219
99220
99221 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3) {
99222   unsigned int jresult ;
99223   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
99224   Dali::Toolkit::Slider arg2 ;
99225   float arg3 ;
99226   Dali::Toolkit::Slider *argp2 ;
99227   bool result;
99228
99229   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
99230   argp2 = (Dali::Toolkit::Slider *)jarg2;
99231   if (!argp2) {
99232     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
99233     return 0;
99234   }
99235   arg2 = *argp2;
99236   arg3 = (float)jarg3;
99237   {
99238     try {
99239       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(arg1,arg2,arg3);
99240     } catch (std::out_of_range& e) {
99241       {
99242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99243       };
99244     } catch (std::exception& e) {
99245       {
99246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99247       };
99248     } catch (Dali::DaliException e) {
99249       {
99250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99251       };
99252     } catch (...) {
99253       {
99254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99255       };
99256     }
99257   }
99258
99259   jresult = result;
99260   return jresult;
99261 }
99262
99263
99264 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderValueChangedSignal() {
99265   void * jresult ;
99266   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *result = 0 ;
99267
99268   {
99269     try {
99270       result = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,float) >();
99271     } catch (std::out_of_range& e) {
99272       {
99273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99274       };
99275     } catch (std::exception& e) {
99276       {
99277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99278       };
99279     } catch (Dali::DaliException e) {
99280       {
99281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99282       };
99283     } catch (...) {
99284       {
99285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99286       };
99287     }
99288   }
99289
99290   jresult = (void *)result;
99291   return jresult;
99292 }
99293
99294
99295 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderValueChangedSignal(void * jarg1) {
99296   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
99297
99298   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
99299   {
99300     try {
99301       delete arg1;
99302     } catch (std::out_of_range& e) {
99303       {
99304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99305       };
99306     } catch (std::exception& e) {
99307       {
99308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99309       };
99310     } catch (Dali::DaliException e) {
99311       {
99312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99313       };
99314     } catch (...) {
99315       {
99316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99317       };
99318     }
99319   }
99320
99321 }
99322
99323
99324 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Empty(void * jarg1) {
99325   unsigned int jresult ;
99326   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99327   bool result;
99328
99329   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99330   {
99331     try {
99332       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
99333     } catch (std::out_of_range& e) {
99334       {
99335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99336       };
99337     } catch (std::exception& e) {
99338       {
99339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99340       };
99341     } catch (Dali::DaliException e) {
99342       {
99343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99344       };
99345     } catch (...) {
99346       {
99347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99348       };
99349     }
99350   }
99351
99352   jresult = result;
99353   return jresult;
99354 }
99355
99356
99357 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_GetConnectionCount(void * jarg1) {
99358   unsigned long jresult ;
99359   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99360   std::size_t result;
99361
99362   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99363   {
99364     try {
99365       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
99366     } catch (std::out_of_range& e) {
99367       {
99368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99369       };
99370     } catch (std::exception& e) {
99371       {
99372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99373       };
99374     } catch (Dali::DaliException e) {
99375       {
99376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99377       };
99378     } catch (...) {
99379       {
99380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99381       };
99382     }
99383   }
99384
99385   jresult = (unsigned long)result;
99386   return jresult;
99387 }
99388
99389
99390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Connect(void * jarg1, void * jarg2) {
99391   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99392   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
99393
99394   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99395   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
99396   {
99397     try {
99398       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(arg1,arg2);
99399     } catch (std::out_of_range& e) {
99400       {
99401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99402       };
99403     } catch (std::exception& e) {
99404       {
99405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99406       };
99407     } catch (Dali::DaliException e) {
99408       {
99409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99410       };
99411     } catch (...) {
99412       {
99413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99414       };
99415     }
99416   }
99417
99418 }
99419
99420
99421 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Disconnect(void * jarg1, void * jarg2) {
99422   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99423   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
99424
99425   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99426   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
99427   {
99428     try {
99429       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(arg1,arg2);
99430     } catch (std::out_of_range& e) {
99431       {
99432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99433       };
99434     } catch (std::exception& e) {
99435       {
99436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99437       };
99438     } catch (Dali::DaliException e) {
99439       {
99440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99441       };
99442     } catch (...) {
99443       {
99444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99445       };
99446     }
99447   }
99448
99449 }
99450
99451
99452 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
99453   unsigned int jresult ;
99454   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99455   Dali::Toolkit::Slider arg2 ;
99456   int arg3 ;
99457   Dali::Toolkit::Slider *argp2 ;
99458   bool result;
99459
99460   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99461   argp2 = (Dali::Toolkit::Slider *)jarg2;
99462   if (!argp2) {
99463     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
99464     return 0;
99465   }
99466   arg2 = *argp2;
99467   arg3 = (int)jarg3;
99468   {
99469     try {
99470       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(arg1,arg2,arg3);
99471     } catch (std::out_of_range& e) {
99472       {
99473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99474       };
99475     } catch (std::exception& e) {
99476       {
99477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99478       };
99479     } catch (Dali::DaliException e) {
99480       {
99481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99482       };
99483     } catch (...) {
99484       {
99485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99486       };
99487     }
99488   }
99489
99490   jresult = result;
99491   return jresult;
99492 }
99493
99494
99495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderMarkReachedSignal() {
99496   void * jresult ;
99497   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *result = 0 ;
99498
99499   {
99500     try {
99501       result = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,int) >();
99502     } catch (std::out_of_range& e) {
99503       {
99504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99505       };
99506     } catch (std::exception& e) {
99507       {
99508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99509       };
99510     } catch (Dali::DaliException e) {
99511       {
99512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99513       };
99514     } catch (...) {
99515       {
99516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99517       };
99518     }
99519   }
99520
99521   jresult = (void *)result;
99522   return jresult;
99523 }
99524
99525
99526 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderMarkReachedSignal(void * jarg1) {
99527   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99528
99529   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99530   {
99531     try {
99532       delete arg1;
99533     } catch (std::out_of_range& e) {
99534       {
99535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99536       };
99537     } catch (std::exception& e) {
99538       {
99539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99540       };
99541     } catch (Dali::DaliException e) {
99542       {
99543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99544       };
99545     } catch (...) {
99546       {
99547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99548       };
99549     }
99550   }
99551
99552 }
99553
99554
99555 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_0() {
99556   void * jresult ;
99557   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99558
99559   {
99560     try {
99561       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >();
99562     } catch (std::out_of_range& e) {
99563       {
99564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99565       };
99566     } catch (std::exception& e) {
99567       {
99568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99569       };
99570     } catch (Dali::DaliException e) {
99571       {
99572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99573       };
99574     } catch (...) {
99575       {
99576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99577       };
99578     }
99579   }
99580
99581   jresult = (void *)result;
99582   return jresult;
99583 }
99584
99585
99586 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_1(void * jarg1) {
99587   void * jresult ;
99588   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
99589   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99590
99591   arg1 = (Dali::Toolkit::Ruler *)jarg1;
99592   {
99593     try {
99594       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >(arg1);
99595     } catch (std::out_of_range& e) {
99596       {
99597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99598       };
99599     } catch (std::exception& e) {
99600       {
99601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99602       };
99603     } catch (Dali::DaliException e) {
99604       {
99605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99606       };
99607     } catch (...) {
99608       {
99609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99610       };
99611     }
99612   }
99613
99614   jresult = (void *)result;
99615   return jresult;
99616 }
99617
99618
99619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_2(void * jarg1) {
99620   void * jresult ;
99621   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = 0 ;
99622   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99623
99624   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99625   if (!arg1) {
99626     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
99627     return 0;
99628   }
99629   {
99630     try {
99631       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg1);
99632     } catch (std::out_of_range& e) {
99633       {
99634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99635       };
99636     } catch (std::exception& e) {
99637       {
99638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99639       };
99640     } catch (Dali::DaliException e) {
99641       {
99642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99643       };
99644     } catch (...) {
99645       {
99646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99647       };
99648     }
99649   }
99650
99651   jresult = (void *)result;
99652   return jresult;
99653 }
99654
99655
99656 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerPtr(void * jarg1) {
99657   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99658
99659   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99660   {
99661     try {
99662       delete arg1;
99663     } catch (std::out_of_range& e) {
99664       {
99665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99666       };
99667     } catch (std::exception& e) {
99668       {
99669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99670       };
99671     } catch (Dali::DaliException e) {
99672       {
99673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99674       };
99675     } catch (...) {
99676       {
99677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99678       };
99679     }
99680   }
99681
99682 }
99683
99684
99685 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Get(void * jarg1) {
99686   void * jresult ;
99687   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99688   Dali::Toolkit::Ruler *result = 0 ;
99689
99690   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99691   {
99692     try {
99693       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->Get();
99694     } catch (std::out_of_range& e) {
99695       {
99696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99697       };
99698     } catch (std::exception& e) {
99699       {
99700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99701       };
99702     } catch (Dali::DaliException e) {
99703       {
99704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99705       };
99706     } catch (...) {
99707       {
99708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99709       };
99710     }
99711   }
99712
99713   jresult = (void *)result;
99714   return jresult;
99715 }
99716
99717
99718 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___deref__(void * jarg1) {
99719   void * jresult ;
99720   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99721   Dali::Toolkit::Ruler *result = 0 ;
99722
99723   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99724   {
99725     try {
99726       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator ->();
99727     } catch (std::out_of_range& e) {
99728       {
99729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99730       };
99731     } catch (std::exception& e) {
99732       {
99733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99734       };
99735     } catch (Dali::DaliException e) {
99736       {
99737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99738       };
99739     } catch (...) {
99740       {
99741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99742       };
99743     }
99744   }
99745
99746   jresult = (void *)result;
99747   return jresult;
99748 }
99749
99750
99751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___ref__(void * jarg1) {
99752   void * jresult ;
99753   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99754   Dali::Toolkit::Ruler *result = 0 ;
99755
99756   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99757   {
99758     try {
99759       result = (Dali::Toolkit::Ruler *) &((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator *();
99760     } catch (std::out_of_range& e) {
99761       {
99762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99763       };
99764     } catch (std::exception& e) {
99765       {
99766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99767       };
99768     } catch (Dali::DaliException e) {
99769       {
99770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99771       };
99772     } catch (...) {
99773       {
99774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99775       };
99776     }
99777   }
99778
99779   jresult = (void *)result;
99780   return jresult;
99781 }
99782
99783
99784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_0(void * jarg1, void * jarg2) {
99785   void * jresult ;
99786   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99787   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg2 = 0 ;
99788   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99789
99790   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99791   arg2 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg2;
99792   if (!arg2) {
99793     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
99794     return 0;
99795   }
99796   {
99797     try {
99798       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg2);
99799     } catch (std::out_of_range& e) {
99800       {
99801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99802       };
99803     } catch (std::exception& e) {
99804       {
99805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99806       };
99807     } catch (Dali::DaliException e) {
99808       {
99809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99810       };
99811     } catch (...) {
99812       {
99813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99814       };
99815     }
99816   }
99817
99818   jresult = (void *)result;
99819   return jresult;
99820 }
99821
99822
99823 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_1(void * jarg1, void * jarg2) {
99824   void * jresult ;
99825   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99826   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
99827   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99828
99829   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99830   arg2 = (Dali::Toolkit::Ruler *)jarg2;
99831   {
99832     try {
99833       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =(arg2);
99834     } catch (std::out_of_range& e) {
99835       {
99836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99837       };
99838     } catch (std::exception& e) {
99839       {
99840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99841       };
99842     } catch (Dali::DaliException e) {
99843       {
99844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99845       };
99846     } catch (...) {
99847       {
99848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99849       };
99850     }
99851   }
99852
99853   jresult = (void *)result;
99854   return jresult;
99855 }
99856
99857
99858 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_0(void * jarg1) {
99859   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99860
99861   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99862   {
99863     try {
99864       (arg1)->Reset();
99865     } catch (std::out_of_range& e) {
99866       {
99867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99868       };
99869     } catch (std::exception& e) {
99870       {
99871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99872       };
99873     } catch (Dali::DaliException e) {
99874       {
99875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99876       };
99877     } catch (...) {
99878       {
99879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99880       };
99881     }
99882   }
99883
99884 }
99885
99886
99887 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_1(void * jarg1, void * jarg2) {
99888   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99889   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
99890
99891   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99892   arg2 = (Dali::Toolkit::Ruler *)jarg2;
99893   {
99894     try {
99895       (arg1)->Reset(arg2);
99896     } catch (std::out_of_range& e) {
99897       {
99898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99899       };
99900     } catch (std::exception& e) {
99901       {
99902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99903       };
99904     } catch (Dali::DaliException e) {
99905       {
99906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99907       };
99908     } catch (...) {
99909       {
99910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99911       };
99912     }
99913   }
99914
99915 }
99916
99917
99918 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Detach(void * jarg1) {
99919   void * jresult ;
99920   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99921   Dali::Toolkit::Ruler *result = 0 ;
99922
99923   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99924   {
99925     try {
99926       result = (Dali::Toolkit::Ruler *)(arg1)->Detach();
99927     } catch (std::out_of_range& e) {
99928       {
99929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99930       };
99931     } catch (std::exception& e) {
99932       {
99933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99934       };
99935     } catch (Dali::DaliException e) {
99936       {
99937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99938       };
99939     } catch (...) {
99940       {
99941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99942       };
99943     }
99944   }
99945
99946   jresult = (void *)result;
99947   return jresult;
99948 }
99949
99950
99951 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
99952   float jresult ;
99953   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99954   float arg2 ;
99955   float arg3 ;
99956   float result;
99957
99958   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99959   arg2 = (float)jarg2;
99960   arg3 = (float)jarg3;
99961   {
99962     try {
99963       result = (float)(*arg1)->Snap(arg2,arg3);
99964     } catch (std::out_of_range& e) {
99965       {
99966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99967       };
99968     } catch (std::exception& e) {
99969       {
99970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99971       };
99972     } catch (Dali::DaliException e) {
99973       {
99974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99975       };
99976     } catch (...) {
99977       {
99978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99979       };
99980     }
99981   }
99982
99983   jresult = result;
99984   return jresult;
99985 }
99986
99987
99988 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_1(void * jarg1, float jarg2) {
99989   float jresult ;
99990   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99991   float arg2 ;
99992   float result;
99993
99994   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99995   arg2 = (float)jarg2;
99996   {
99997     try {
99998       result = (float)(*arg1)->Snap(arg2);
99999     } catch (std::out_of_range& e) {
100000       {
100001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100002       };
100003     } catch (std::exception& e) {
100004       {
100005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100006       };
100007     } catch (Dali::DaliException e) {
100008       {
100009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100010       };
100011     } catch (...) {
100012       {
100013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100014       };
100015     }
100016   }
100017
100018   jresult = result;
100019   return jresult;
100020 }
100021
100022
100023 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
100024   float jresult ;
100025   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100026   unsigned int arg2 ;
100027   unsigned int *arg3 = 0 ;
100028   bool arg4 ;
100029   float result;
100030
100031   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100032   arg2 = (unsigned int)jarg2;
100033   arg3 = (unsigned int *)jarg3;
100034   arg4 = jarg4 ? true : false;
100035   {
100036     try {
100037       result = (float)(*arg1)->GetPositionFromPage(arg2,*arg3,arg4);
100038     } catch (std::out_of_range& e) {
100039       {
100040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100041       };
100042     } catch (std::exception& e) {
100043       {
100044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100045       };
100046     } catch (Dali::DaliException e) {
100047       {
100048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100049       };
100050     } catch (...) {
100051       {
100052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100053       };
100054     }
100055   }
100056
100057   jresult = result;
100058   return jresult;
100059 }
100060
100061
100062 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
100063   unsigned int jresult ;
100064   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100065   float arg2 ;
100066   bool arg3 ;
100067   unsigned int result;
100068
100069   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100070   arg2 = (float)jarg2;
100071   arg3 = jarg3 ? true : false;
100072   {
100073     try {
100074       result = (unsigned int)(*arg1)->GetPageFromPosition(arg2,arg3);
100075     } catch (std::out_of_range& e) {
100076       {
100077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100078       };
100079     } catch (std::exception& e) {
100080       {
100081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100082       };
100083     } catch (Dali::DaliException e) {
100084       {
100085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100086       };
100087     } catch (...) {
100088       {
100089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100090       };
100091     }
100092   }
100093
100094   jresult = result;
100095   return jresult;
100096 }
100097
100098
100099 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetTotalPages(void * jarg1) {
100100   unsigned int jresult ;
100101   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100102   unsigned int result;
100103
100104   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100105   {
100106     try {
100107       result = (unsigned int)(*arg1)->GetTotalPages();
100108     } catch (std::out_of_range& e) {
100109       {
100110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100111       };
100112     } catch (std::exception& e) {
100113       {
100114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100115       };
100116     } catch (Dali::DaliException e) {
100117       {
100118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100119       };
100120     } catch (...) {
100121       {
100122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100123       };
100124     }
100125   }
100126
100127   jresult = result;
100128   return jresult;
100129 }
100130
100131
100132 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_GetType(void * jarg1) {
100133   int jresult ;
100134   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100135   Dali::Toolkit::Ruler::RulerType result;
100136
100137   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100138   {
100139     try {
100140       result = (Dali::Toolkit::Ruler::RulerType)(*arg1)->GetType();
100141     } catch (std::out_of_range& e) {
100142       {
100143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100144       };
100145     } catch (std::exception& e) {
100146       {
100147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100148       };
100149     } catch (Dali::DaliException e) {
100150       {
100151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100152       };
100153     } catch (...) {
100154       {
100155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100156       };
100157     }
100158   }
100159
100160   jresult = (int)result;
100161   return jresult;
100162 }
100163
100164
100165 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_IsEnabled(void * jarg1) {
100166   unsigned int jresult ;
100167   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100168   bool result;
100169
100170   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100171   {
100172     try {
100173       result = (bool)(*arg1)->IsEnabled();
100174     } catch (std::out_of_range& e) {
100175       {
100176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100177       };
100178     } catch (std::exception& e) {
100179       {
100180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100181       };
100182     } catch (Dali::DaliException e) {
100183       {
100184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100185       };
100186     } catch (...) {
100187       {
100188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100189       };
100190     }
100191   }
100192
100193   jresult = result;
100194   return jresult;
100195 }
100196
100197
100198 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Enable(void * jarg1) {
100199   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100200
100201   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100202   {
100203     try {
100204       (*arg1)->Enable();
100205     } catch (std::out_of_range& e) {
100206       {
100207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100208       };
100209     } catch (std::exception& e) {
100210       {
100211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100212       };
100213     } catch (Dali::DaliException e) {
100214       {
100215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100216       };
100217     } catch (...) {
100218       {
100219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100220       };
100221     }
100222   }
100223
100224 }
100225
100226
100227 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Disable(void * jarg1) {
100228   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100229
100230   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100231   {
100232     try {
100233       (*arg1)->Disable();
100234     } catch (std::out_of_range& e) {
100235       {
100236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100237       };
100238     } catch (std::exception& e) {
100239       {
100240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100241       };
100242     } catch (Dali::DaliException e) {
100243       {
100244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100245       };
100246     } catch (...) {
100247       {
100248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100249       };
100250     }
100251   }
100252
100253 }
100254
100255
100256 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_SetDomain(void * jarg1, void * jarg2) {
100257   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100258   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
100259   Dali::Toolkit::RulerDomain *argp2 ;
100260
100261   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100262   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
100263   if (!argp2) {
100264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
100265     return ;
100266   }
100267   arg2 = *argp2;
100268   {
100269     try {
100270       (*arg1)->SetDomain(arg2);
100271     } catch (std::out_of_range& e) {
100272       {
100273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100274       };
100275     } catch (std::exception& e) {
100276       {
100277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100278       };
100279     } catch (Dali::DaliException e) {
100280       {
100281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100282       };
100283     } catch (...) {
100284       {
100285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100286       };
100287     }
100288   }
100289
100290 }
100291
100292
100293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_GetDomain(void * jarg1) {
100294   void * jresult ;
100295   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100296   Dali::Toolkit::RulerDomain *result = 0 ;
100297
100298   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100299   {
100300     try {
100301       result = (Dali::Toolkit::RulerDomain *) &(*arg1)->GetDomain();
100302     } catch (std::out_of_range& e) {
100303       {
100304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100305       };
100306     } catch (std::exception& e) {
100307       {
100308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100309       };
100310     } catch (Dali::DaliException e) {
100311       {
100312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100313       };
100314     } catch (...) {
100315       {
100316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100317       };
100318     }
100319   }
100320
100321   jresult = (void *)result;
100322   return jresult;
100323 }
100324
100325
100326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_DisableDomain(void * jarg1) {
100327   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100328
100329   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100330   {
100331     try {
100332       (*arg1)->DisableDomain();
100333     } catch (std::out_of_range& e) {
100334       {
100335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100336       };
100337     } catch (std::exception& e) {
100338       {
100339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100340       };
100341     } catch (Dali::DaliException e) {
100342       {
100343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100344       };
100345     } catch (...) {
100346       {
100347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100348       };
100349     }
100350   }
100351
100352 }
100353
100354
100355 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
100356   float jresult ;
100357   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100358   float arg2 ;
100359   float arg3 ;
100360   float arg4 ;
100361   float result;
100362
100363   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100364   arg2 = (float)jarg2;
100365   arg3 = (float)jarg3;
100366   arg4 = (float)jarg4;
100367   {
100368     try {
100369       result = (float)(*arg1)->Clamp(arg2,arg3,arg4);
100370     } catch (std::out_of_range& e) {
100371       {
100372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100373       };
100374     } catch (std::exception& e) {
100375       {
100376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100377       };
100378     } catch (Dali::DaliException e) {
100379       {
100380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100381       };
100382     } catch (...) {
100383       {
100384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100385       };
100386     }
100387   }
100388
100389   jresult = result;
100390   return jresult;
100391 }
100392
100393
100394 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
100395   float jresult ;
100396   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100397   float arg2 ;
100398   float arg3 ;
100399   float result;
100400
100401   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100402   arg2 = (float)jarg2;
100403   arg3 = (float)jarg3;
100404   {
100405     try {
100406       result = (float)(*arg1)->Clamp(arg2,arg3);
100407     } catch (std::out_of_range& e) {
100408       {
100409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100410       };
100411     } catch (std::exception& e) {
100412       {
100413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100414       };
100415     } catch (Dali::DaliException e) {
100416       {
100417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100418       };
100419     } catch (...) {
100420       {
100421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100422       };
100423     }
100424   }
100425
100426   jresult = result;
100427   return jresult;
100428 }
100429
100430
100431 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_2(void * jarg1, float jarg2) {
100432   float jresult ;
100433   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100434   float arg2 ;
100435   float result;
100436
100437   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100438   arg2 = (float)jarg2;
100439   {
100440     try {
100441       result = (float)(*arg1)->Clamp(arg2);
100442     } catch (std::out_of_range& e) {
100443       {
100444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100445       };
100446     } catch (std::exception& e) {
100447       {
100448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100449       };
100450     } catch (Dali::DaliException e) {
100451       {
100452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100453       };
100454     } catch (...) {
100455       {
100456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100457       };
100458     }
100459   }
100460
100461   jresult = result;
100462   return jresult;
100463 }
100464
100465
100466 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
100467   float jresult ;
100468   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100469   float arg2 ;
100470   float arg3 ;
100471   float arg4 ;
100472   Dali::Toolkit::ClampState *arg5 = 0 ;
100473   float result;
100474
100475   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100476   arg2 = (float)jarg2;
100477   arg3 = (float)jarg3;
100478   arg4 = (float)jarg4;
100479   arg5 = (Dali::Toolkit::ClampState *)jarg5;
100480   if (!arg5) {
100481     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
100482     return 0;
100483   }
100484   {
100485     try {
100486       result = (float)(*arg1)->Clamp(arg2,arg3,arg4,*arg5);
100487     } catch (std::out_of_range& e) {
100488       {
100489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100490       };
100491     } catch (std::exception& e) {
100492       {
100493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100494       };
100495     } catch (Dali::DaliException e) {
100496       {
100497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100498       };
100499     } catch (...) {
100500       {
100501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100502       };
100503     }
100504   }
100505
100506   jresult = result;
100507   return jresult;
100508 }
100509
100510
100511 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
100512   float jresult ;
100513   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100514   float arg2 ;
100515   float arg3 ;
100516   float arg4 ;
100517   float arg5 ;
100518   float result;
100519
100520   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100521   arg2 = (float)jarg2;
100522   arg3 = (float)jarg3;
100523   arg4 = (float)jarg4;
100524   arg5 = (float)jarg5;
100525   {
100526     try {
100527       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
100528     } catch (std::out_of_range& e) {
100529       {
100530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100531       };
100532     } catch (std::exception& e) {
100533       {
100534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100535       };
100536     } catch (Dali::DaliException e) {
100537       {
100538         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100539       };
100540     } catch (...) {
100541       {
100542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100543       };
100544     }
100545   }
100546
100547   jresult = result;
100548   return jresult;
100549 }
100550
100551
100552 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
100553   float jresult ;
100554   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100555   float arg2 ;
100556   float arg3 ;
100557   float arg4 ;
100558   float result;
100559
100560   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100561   arg2 = (float)jarg2;
100562   arg3 = (float)jarg3;
100563   arg4 = (float)jarg4;
100564   {
100565     try {
100566       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4);
100567     } catch (std::out_of_range& e) {
100568       {
100569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100570       };
100571     } catch (std::exception& e) {
100572       {
100573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100574       };
100575     } catch (Dali::DaliException e) {
100576       {
100577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100578       };
100579     } catch (...) {
100580       {
100581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100582       };
100583     }
100584   }
100585
100586   jresult = result;
100587   return jresult;
100588 }
100589
100590
100591 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
100592   float jresult ;
100593   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100594   float arg2 ;
100595   float arg3 ;
100596   float result;
100597
100598   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100599   arg2 = (float)jarg2;
100600   arg3 = (float)jarg3;
100601   {
100602     try {
100603       result = (float)(*arg1)->SnapAndClamp(arg2,arg3);
100604     } catch (std::out_of_range& e) {
100605       {
100606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100607       };
100608     } catch (std::exception& e) {
100609       {
100610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100611       };
100612     } catch (Dali::DaliException e) {
100613       {
100614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100615       };
100616     } catch (...) {
100617       {
100618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100619       };
100620     }
100621   }
100622
100623   jresult = result;
100624   return jresult;
100625 }
100626
100627
100628 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
100629   float jresult ;
100630   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100631   float arg2 ;
100632   float result;
100633
100634   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100635   arg2 = (float)jarg2;
100636   {
100637     try {
100638       result = (float)(*arg1)->SnapAndClamp(arg2);
100639     } catch (std::out_of_range& e) {
100640       {
100641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100642       };
100643     } catch (std::exception& e) {
100644       {
100645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100646       };
100647     } catch (Dali::DaliException e) {
100648       {
100649         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100650       };
100651     } catch (...) {
100652       {
100653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100654       };
100655     }
100656   }
100657
100658   jresult = result;
100659   return jresult;
100660 }
100661
100662
100663 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
100664   float jresult ;
100665   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100666   float arg2 ;
100667   float arg3 ;
100668   float arg4 ;
100669   float arg5 ;
100670   Dali::Toolkit::ClampState *arg6 = 0 ;
100671   float result;
100672
100673   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100674   arg2 = (float)jarg2;
100675   arg3 = (float)jarg3;
100676   arg4 = (float)jarg4;
100677   arg5 = (float)jarg5;
100678   arg6 = (Dali::Toolkit::ClampState *)jarg6;
100679   if (!arg6) {
100680     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
100681     return 0;
100682   }
100683   {
100684     try {
100685       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
100686     } catch (std::out_of_range& e) {
100687       {
100688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100689       };
100690     } catch (std::exception& e) {
100691       {
100692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100693       };
100694     } catch (Dali::DaliException e) {
100695       {
100696         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100697       };
100698     } catch (...) {
100699       {
100700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100701       };
100702     }
100703   }
100704
100705   jresult = result;
100706   return jresult;
100707 }
100708
100709
100710 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reference(void * jarg1) {
100711   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100712
100713   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100714   {
100715     try {
100716       (*arg1)->Reference();
100717     } catch (std::out_of_range& e) {
100718       {
100719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100720       };
100721     } catch (std::exception& e) {
100722       {
100723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100724       };
100725     } catch (Dali::DaliException e) {
100726       {
100727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100728       };
100729     } catch (...) {
100730       {
100731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100732       };
100733     }
100734   }
100735
100736 }
100737
100738
100739 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Unreference(void * jarg1) {
100740   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100741
100742   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100743   {
100744     try {
100745       (*arg1)->Unreference();
100746     } catch (std::out_of_range& e) {
100747       {
100748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100749       };
100750     } catch (std::exception& e) {
100751       {
100752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100753       };
100754     } catch (Dali::DaliException e) {
100755       {
100756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100757       };
100758     } catch (...) {
100759       {
100760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100761       };
100762     }
100763   }
100764
100765 }
100766
100767
100768 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_ReferenceCount(void * jarg1) {
100769   int jresult ;
100770   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100771   int result;
100772
100773   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100774   {
100775     try {
100776       result = (int)(*arg1)->ReferenceCount();
100777     } catch (std::out_of_range& e) {
100778       {
100779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100780       };
100781     } catch (std::exception& e) {
100782       {
100783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100784       };
100785     } catch (Dali::DaliException e) {
100786       {
100787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100788       };
100789     } catch (...) {
100790       {
100791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100792       };
100793     }
100794   }
100795
100796   jresult = result;
100797   return jresult;
100798 }
100799
100800
100801 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Empty(void * jarg1) {
100802   unsigned int jresult ;
100803   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100804   bool result;
100805
100806   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100807   {
100808     try {
100809       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
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 (Dali::DaliException e) {
100819       {
100820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100821       };
100822     } catch (...) {
100823       {
100824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100825       };
100826     }
100827   }
100828
100829   jresult = result;
100830   return jresult;
100831 }
100832
100833
100834 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_GetConnectionCount(void * jarg1) {
100835   unsigned long jresult ;
100836   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100837   std::size_t result;
100838
100839   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100840   {
100841     try {
100842       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
100843     } catch (std::out_of_range& e) {
100844       {
100845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100846       };
100847     } catch (std::exception& e) {
100848       {
100849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100850       };
100851     } catch (Dali::DaliException e) {
100852       {
100853         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100854       };
100855     } catch (...) {
100856       {
100857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100858       };
100859     }
100860   }
100861
100862   jresult = (unsigned long)result;
100863   return jresult;
100864 }
100865
100866
100867 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Connect(void * jarg1, void * jarg2) {
100868   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100869   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
100870
100871   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100872   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
100873   {
100874     try {
100875       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
100876     } catch (std::out_of_range& e) {
100877       {
100878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100879       };
100880     } catch (std::exception& e) {
100881       {
100882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100883       };
100884     } catch (Dali::DaliException e) {
100885       {
100886         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100887       };
100888     } catch (...) {
100889       {
100890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100891       };
100892     }
100893   }
100894
100895 }
100896
100897
100898 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Disconnect(void * jarg1, void * jarg2) {
100899   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100900   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
100901
100902   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100903   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
100904   {
100905     try {
100906       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
100907     } catch (std::out_of_range& e) {
100908       {
100909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100910       };
100911     } catch (std::exception& e) {
100912       {
100913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100914       };
100915     } catch (Dali::DaliException e) {
100916       {
100917         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100918       };
100919     } catch (...) {
100920       {
100921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100922       };
100923     }
100924   }
100925
100926 }
100927
100928
100929 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Emit(void * jarg1, void * jarg2) {
100930   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100931   Dali::Toolkit::Control arg2 ;
100932   Dali::Toolkit::Control *argp2 ;
100933
100934   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100935   argp2 = (Dali::Toolkit::Control *)jarg2;
100936   if (!argp2) {
100937     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
100938     return ;
100939   }
100940   arg2 = *argp2;
100941   {
100942     try {
100943       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
100944     } catch (std::out_of_range& e) {
100945       {
100946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100947       };
100948     } catch (std::exception& e) {
100949       {
100950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100951       };
100952     } catch (Dali::DaliException e) {
100953       {
100954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100955       };
100956     } catch (...) {
100957       {
100958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100959       };
100960     }
100961   }
100962
100963 }
100964
100965
100966 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewResourceReadySignal() {
100967   void * jresult ;
100968   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
100969
100970   {
100971     try {
100972       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
100973     } catch (std::out_of_range& e) {
100974       {
100975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100976       };
100977     } catch (std::exception& e) {
100978       {
100979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100980       };
100981     } catch (Dali::DaliException e) {
100982       {
100983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100984       };
100985     } catch (...) {
100986       {
100987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100988       };
100989     }
100990   }
100991
100992   jresult = (void *)result;
100993   return jresult;
100994 }
100995
100996
100997 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewResourceReadySignal(void * jarg1) {
100998   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100999
101000   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
101001   {
101002     try {
101003       delete arg1;
101004     } catch (std::out_of_range& e) {
101005       {
101006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101007       };
101008     } catch (std::exception& e) {
101009       {
101010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101011       };
101012     } catch (Dali::DaliException e) {
101013       {
101014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
101015       };
101016     } catch (...) {
101017       {
101018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101019       };
101020     }
101021   }
101022
101023 }
101024
101025 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_GetRefObjectPtr(Dali::BaseHandle *arg1) {
101026   Dali::RefObject *result = NULL;
101027
101028   if (arg1)
101029   {
101030     result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
101031   }
101032   return result;
101033 }
101034
101035 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_BaseObject_SWIGUpcast(Dali::BaseObject *jarg1) {
101036     return (Dali::RefObject *)jarg1;
101037 }
101038
101039 SWIGEXPORT Dali::SignalObserver * SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SWIGUpcast(Dali::ConnectionTrackerInterface *jarg1) {
101040     return (Dali::SignalObserver *)jarg1;
101041 }
101042
101043 SWIGEXPORT Dali::ConnectionTrackerInterface * SWIGSTDCALL CSharp_Dali_ConnectionTracker_SWIGUpcast(Dali::ConnectionTracker *jarg1) {
101044     return (Dali::ConnectionTrackerInterface *)jarg1;
101045 }
101046
101047 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ObjectRegistry_SWIGUpcast(Dali::ObjectRegistry *jarg1) {
101048     return (Dali::BaseHandle *)jarg1;
101049 }
101050
101051 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyCondition_SWIGUpcast(Dali::PropertyCondition *jarg1) {
101052     return (Dali::BaseHandle *)jarg1;
101053 }
101054
101055 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyNotification_SWIGUpcast(Dali::PropertyNotification *jarg1) {
101056     return (Dali::BaseHandle *)jarg1;
101057 }
101058
101059 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Handle_SWIGUpcast(Dali::Handle *jarg1) {
101060     return (Dali::BaseHandle *)jarg1;
101061 }
101062
101063 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeInfo_SWIGUpcast(Dali::TypeInfo *jarg1) {
101064     return (Dali::BaseHandle *)jarg1;
101065 }
101066
101067 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeRegistry_SWIGUpcast(Dali::TypeRegistry *jarg1) {
101068     return (Dali::BaseHandle *)jarg1;
101069 }
101070
101071 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Image_SWIGUpcast(Dali::Image *jarg1) {
101072     return (Dali::BaseHandle *)jarg1;
101073 }
101074
101075 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelData_SWIGUpcast(Dali::PixelData *jarg1) {
101076     return (Dali::BaseHandle *)jarg1;
101077 }
101078
101079 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Texture_SWIGUpcast(Dali::Texture *jarg1) {
101080     return (Dali::BaseHandle *)jarg1;
101081 }
101082
101083 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Sampler_SWIGUpcast(Dali::Sampler *jarg1) {
101084     return (Dali::BaseHandle *)jarg1;
101085 }
101086
101087 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TextureSet_SWIGUpcast(Dali::TextureSet *jarg1) {
101088     return (Dali::BaseHandle *)jarg1;
101089 }
101090
101091 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyBuffer_SWIGUpcast(Dali::PropertyBuffer *jarg1) {
101092     return (Dali::BaseHandle *)jarg1;
101093 }
101094
101095 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Geometry_SWIGUpcast(Dali::Geometry *jarg1) {
101096     return (Dali::BaseHandle *)jarg1;
101097 }
101098
101099 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Shader_SWIGUpcast(Dali::Shader *jarg1) {
101100     return (Dali::Handle *)jarg1;
101101 }
101102
101103 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Renderer_SWIGUpcast(Dali::Renderer *jarg1) {
101104     return (Dali::Handle *)jarg1;
101105 }
101106
101107 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_FrameBuffer_SWIGUpcast(Dali::FrameBuffer *jarg1) {
101108     return (Dali::BaseHandle *)jarg1;
101109 }
101110
101111 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_RenderTaskList_SWIGUpcast(Dali::RenderTaskList *jarg1) {
101112     return (Dali::BaseHandle *)jarg1;
101113 }
101114
101115 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_RenderTask_SWIGUpcast(Dali::RenderTask *jarg1) {
101116     return (Dali::Handle *)jarg1;
101117 }
101118
101119 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Touch_SWIGUpcast(Dali::TouchData *jarg1) {
101120     return (Dali::BaseHandle *)jarg1;
101121 }
101122
101123 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_GestureDetector_SWIGUpcast(Dali::GestureDetector *jarg1) {
101124     return (Dali::Handle *)jarg1;
101125 }
101126
101127 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SWIGUpcast(Dali::LongPressGestureDetector *jarg1) {
101128     return (Dali::GestureDetector *)jarg1;
101129 }
101130
101131 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_LongPressGesture_SWIGUpcast(Dali::LongPressGesture *jarg1) {
101132     return (Dali::Gesture *)jarg1;
101133 }
101134
101135 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Actor_SWIGUpcast(Dali::Actor *jarg1) {
101136     return (Dali::Handle *)jarg1;
101137 }
101138
101139 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_Layer_SWIGUpcast(Dali::Layer *jarg1) {
101140     return (Dali::Actor *)jarg1;
101141 }
101142
101143 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Stage_SWIGUpcast(Dali::Stage *jarg1) {
101144     return (Dali::BaseHandle *)jarg1;
101145 }
101146
101147 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_CustomActorImpl_SWIGUpcast(Dali::CustomActorImpl *jarg1) {
101148     return (Dali::RefObject *)jarg1;
101149 }
101150
101151 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CustomActor_SWIGUpcast(Dali::CustomActor *jarg1) {
101152     return (Dali::Actor *)jarg1;
101153 }
101154
101155 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PanGestureDetector_SWIGUpcast(Dali::PanGestureDetector *jarg1) {
101156     return (Dali::GestureDetector *)jarg1;
101157 }
101158
101159 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PanGesture_SWIGUpcast(Dali::PanGesture *jarg1) {
101160     return (Dali::Gesture *)jarg1;
101161 }
101162
101163 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_SWIGUpcast(Dali::PinchGestureDetector *jarg1) {
101164     return (Dali::GestureDetector *)jarg1;
101165 }
101166
101167 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PinchGesture_SWIGUpcast(Dali::PinchGesture *jarg1) {
101168     return (Dali::Gesture *)jarg1;
101169 }
101170
101171 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_TapGestureDetector_SWIGUpcast(Dali::TapGestureDetector *jarg1) {
101172     return (Dali::GestureDetector *)jarg1;
101173 }
101174
101175 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_TapGesture_SWIGUpcast(Dali::TapGesture *jarg1) {
101176     return (Dali::Gesture *)jarg1;
101177 }
101178
101179 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyFrames_SWIGUpcast(Dali::KeyFrames *jarg1) {
101180     return (Dali::BaseHandle *)jarg1;
101181 }
101182
101183 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Path_SWIGUpcast(Dali::Path *jarg1) {
101184     return (Dali::Handle *)jarg1;
101185 }
101186
101187 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_LinearConstrainer_SWIGUpcast(Dali::LinearConstrainer *jarg1) {
101188     return (Dali::Handle *)jarg1;
101189 }
101190
101191 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_PathConstrainer_SWIGUpcast(Dali::PathConstrainer *jarg1) {
101192     return (Dali::Handle *)jarg1;
101193 }
101194
101195 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_BufferImage_SWIGUpcast(Dali::BufferImage *jarg1) {
101196     return (Dali::Image *)jarg1;
101197 }
101198
101199 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_SWIGUpcast(Dali::EncodedBufferImage *jarg1) {
101200     return (Dali::Image *)jarg1;
101201 }
101202
101203 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_NativeImage_SWIGUpcast(Dali::NativeImage *jarg1) {
101204     return (Dali::Image *)jarg1;
101205 }
101206
101207 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_NativeImageInterface_SWIGUpcast(Dali::NativeImageInterface *jarg1) {
101208     return (Dali::RefObject *)jarg1;
101209 }
101210
101211 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_ResourceImage_SWIGUpcast(Dali::ResourceImage *jarg1) {
101212     return (Dali::Image *)jarg1;
101213 }
101214
101215 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_FrameBufferImage_SWIGUpcast(Dali::FrameBufferImage *jarg1) {
101216     return (Dali::Image *)jarg1;
101217 }
101218
101219 SWIGEXPORT Dali::ResourceImage * SWIGSTDCALL CSharp_Dali_NinePatchImage_SWIGUpcast(Dali::NinePatchImage *jarg1) {
101220     return (Dali::ResourceImage *)jarg1;
101221 }
101222
101223 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CameraActor_SWIGUpcast(Dali::CameraActor *jarg1) {
101224     return (Dali::Actor *)jarg1;
101225 }
101226
101227 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Timer_SWIGUpcast(Dali::Timer *jarg1) {
101228     return (Dali::BaseHandle *)jarg1;
101229 }
101230
101231 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_SWIGUpcast(Dali::DragAndDropDetector *jarg1) {
101232     return (Dali::BaseHandle *)jarg1;
101233 }
101234
101235
101236 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Builder_SWIGUpcast(Dali::Toolkit::Builder *jarg1) {
101237     return (Dali::BaseHandle *)jarg1;
101238 }
101239
101240 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TransitionData_SWIGUpcast(Dali::Toolkit::TransitionData *jarg1) {
101241     return (Dali::BaseHandle *)jarg1;
101242 }
101243
101244 SWIGEXPORT Dali::CustomActorImpl * SWIGSTDCALL CSharp_Dali_ViewImpl_SWIGUpcast(Dali::Toolkit::Internal::Control *jarg1) {
101245     return (Dali::CustomActorImpl *)jarg1;
101246 }
101247
101248 SWIGEXPORT Dali::CustomActor * SWIGSTDCALL CSharp_Dali_View_SWIGUpcast(Dali::Toolkit::Control *jarg1) {
101249     return (Dali::CustomActor *)jarg1;
101250 }
101251
101252 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SWIGUpcast(Dali::Toolkit::KeyInputFocusManager *jarg1) {
101253     return (Dali::BaseHandle *)jarg1;
101254 }
101255
101256 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Alignment_SWIGUpcast(Dali::Toolkit::Alignment *jarg1) {
101257     return (Dali::Toolkit::Control *)jarg1;
101258 }
101259
101260 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Button_SWIGUpcast(Dali::Toolkit::Button *jarg1) {
101261     return (Dali::Toolkit::Control *)jarg1;
101262 }
101263
101264 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_CheckBoxButton_SWIGUpcast(Dali::Toolkit::CheckBoxButton *jarg1) {
101265     return (Dali::Toolkit::Button *)jarg1;
101266 }
101267
101268 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_PushButton_SWIGUpcast(Dali::Toolkit::PushButton *jarg1) {
101269     return (Dali::Toolkit::Button *)jarg1;
101270 }
101271
101272 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_RadioButton_SWIGUpcast(Dali::Toolkit::RadioButton *jarg1) {
101273     return (Dali::Toolkit::Button *)jarg1;
101274 }
101275
101276 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_FlexContainer_SWIGUpcast(Dali::Toolkit::FlexContainer *jarg1) {
101277     return (Dali::Toolkit::Control *)jarg1;
101278 }
101279
101280 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ImageView_SWIGUpcast(Dali::Toolkit::ImageView *jarg1) {
101281     return (Dali::Toolkit::Control *)jarg1;
101282 }
101283
101284 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Model3dView_SWIGUpcast(Dali::Toolkit::Model3dView *jarg1) {
101285     return (Dali::Toolkit::Control *)jarg1;
101286 }
101287
101288 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ScrollBar_SWIGUpcast(Dali::Toolkit::ScrollBar *jarg1) {
101289     return (Dali::Toolkit::Control *)jarg1;
101290 }
101291
101292 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Scrollable_SWIGUpcast(Dali::Toolkit::Scrollable *jarg1) {
101293     return (Dali::Toolkit::Control *)jarg1;
101294 }
101295
101296 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_ItemLayout_SWIGUpcast(Dali::Toolkit::ItemLayout *jarg1) {
101297     return (Dali::RefObject *)jarg1;
101298 }
101299
101300 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ItemView_SWIGUpcast(Dali::Toolkit::ItemView *jarg1) {
101301     return (Dali::Toolkit::Scrollable *)jarg1;
101302 }
101303
101304 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ScrollViewEffect_SWIGUpcast(Dali::Toolkit::ScrollViewEffect *jarg1) {
101305     return (Dali::BaseHandle *)jarg1;
101306 }
101307
101308 SWIGEXPORT Dali::Toolkit::ScrollViewEffect * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_SWIGUpcast(Dali::Toolkit::ScrollViewPagePathEffect *jarg1) {
101309     return (Dali::Toolkit::ScrollViewEffect *)jarg1;
101310 }
101311
101312 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_Ruler_SWIGUpcast(Dali::Toolkit::Ruler *jarg1) {
101313     return (Dali::RefObject *)jarg1;
101314 }
101315
101316 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_DefaultRuler_SWIGUpcast(Dali::Toolkit::DefaultRuler *jarg1) {
101317     return (Dali::Toolkit::Ruler *)jarg1;
101318 }
101319
101320 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_FixedRuler_SWIGUpcast(Dali::Toolkit::FixedRuler *jarg1) {
101321     return (Dali::Toolkit::Ruler *)jarg1;
101322 }
101323
101324 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ScrollView_SWIGUpcast(Dali::Toolkit::ScrollView *jarg1) {
101325     return (Dali::Toolkit::Scrollable *)jarg1;
101326 }
101327
101328 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TableView_SWIGUpcast(Dali::Toolkit::TableView *jarg1) {
101329     return (Dali::Toolkit::Control *)jarg1;
101330 }
101331
101332
101333 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextLabel_SWIGUpcast(Dali::Toolkit::TextLabel *jarg1) {
101334     return (Dali::Toolkit::Control *)jarg1;
101335 }
101336
101337 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AccessibilityManager_SWIGUpcast(Dali::Toolkit::AccessibilityManager *jarg1) {
101338     return (Dali::BaseHandle *)jarg1;
101339 }
101340
101341 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_StyleManager_SWIGUpcast(Dali::Toolkit::StyleManager *jarg1) {
101342     return (Dali::BaseHandle *)jarg1;
101343 }
101344
101345 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Slider_SWIGUpcast(Dali::Toolkit::Slider *jarg1) {
101346     return (Dali::Toolkit::Control *)jarg1;
101347 }
101348
101349 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_VideoView_SWIGUpcast(Dali::Toolkit::VideoView *jarg1) {
101350     return (Dali::Toolkit::Control *)jarg1;
101351 }
101352
101353 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Popup_SWIGUpcast(Dali::Toolkit::Popup *jarg1) {
101354     return (Dali::Toolkit::Control *)jarg1;
101355 }
101356
101357 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ProgressBar_SWIGUpcast(Dali::Toolkit::ProgressBar *jarg1) {
101358     return (Dali::Toolkit::Control *)jarg1;
101359 }
101360
101361 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_GaussianBlurView_SWIGUpcast(Dali::Toolkit::GaussianBlurView *jarg1) {
101362     return (Dali::Toolkit::Control *)jarg1;
101363 }
101364
101365 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_PageTurnView_SWIGUpcast(Dali::Toolkit::PageTurnView *jarg1) {
101366     return (Dali::Toolkit::Control *)jarg1;
101367 }
101368
101369 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_SWIGUpcast(Dali::Toolkit::PageTurnLandscapeView *jarg1) {
101370     return (Dali::Toolkit::PageTurnView *)jarg1;
101371 }
101372
101373 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_SWIGUpcast(Dali::Toolkit::PageTurnPortraitView *jarg1) {
101374     return (Dali::Toolkit::PageTurnView *)jarg1;
101375 }
101376
101377 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_ToggleButton_SWIGUpcast(Dali::Toolkit::ToggleButton *jarg1) {
101378     return (Dali::Toolkit::Button *)jarg1;
101379 }
101380
101381 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualBase_SWIGUpcast(Dali::Toolkit::Visual::Base *jarg1) {
101382     return (Dali::BaseHandle *)jarg1;
101383 }
101384
101385 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualFactory_SWIGUpcast(Dali::Toolkit::VisualFactory *jarg1) {
101386     return (Dali::BaseHandle *)jarg1;
101387 }
101388
101389 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_SWIGUpcast(Dali::Toolkit::AsyncImageLoader *jarg1) {
101390     return (Dali::BaseHandle *)jarg1;
101391 }
101392
101393 /*
101394  * Widget binding
101395  */
101396 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Widget_SWIGUpcast(Dali::Widget *jarg1) {
101397     return (Dali::BaseHandle *)jarg1;
101398 }
101399
101400 SWIGEXPORT Dali::BaseObject * SWIGSTDCALL CSharp_Dali_WidgetImpl_SWIGUpcast(Dali::Internal::Adaptor::Widget *jarg1) {
101401     return (Dali::BaseObject *)jarg1;
101402 }
101403
101404 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_0() {
101405   void * jresult ;
101406   Dali::Widget result;
101407
101408   {
101409     try {
101410       result = Dali::Widget::New();
101411     } catch (std::out_of_range& e) {
101412       {
101413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101414       };
101415     } catch (std::exception& e) {
101416       {
101417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101418       };
101419     } catch (...) {
101420       {
101421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101422       };
101423     }
101424   }
101425   jresult = new Dali::Widget((const Dali::Widget &)result);
101426   return jresult;
101427 }
101428
101429
101430 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_1(void * jarg1) {
101431   void * jresult ;
101432   Dali::Internal::Adaptor::Widget *arg1 = 0 ;
101433   Dali::Widget result;
101434
101435   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101436
101437   if (!arg1) {
101438     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Internal::Adaptor::Widget & type is null", 0);
101439     return 0;
101440   }
101441   {
101442     try {
101443       jresult = new Dali::Widget(arg1);
101444     } catch (std::out_of_range& e) {
101445       {
101446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101447       };
101448     } catch (std::exception& e) {
101449       {
101450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101451       };
101452     } catch (...) {
101453       {
101454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101455       };
101456     }
101457   }
101458   return jresult;
101459 }
101460
101461
101462 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Widget() {
101463   void * jresult ;
101464   Dali::Widget *result = 0 ;
101465
101466   {
101467     try {
101468       result = (Dali::Widget *)new Dali::Widget();
101469     } catch (std::out_of_range& e) {
101470       {
101471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101472       };
101473     } catch (std::exception& e) {
101474       {
101475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101476       };
101477     } catch (...) {
101478       {
101479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101480       };
101481     }
101482   }
101483   jresult = (void *)result;
101484   return jresult;
101485 }
101486
101487
101488 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_Assign(void * jarg1, void * jarg2) {
101489   void * jresult ;
101490   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
101491   Dali::Widget *arg2 = 0 ;
101492   Dali::Widget *result = 0 ;
101493
101494   arg1 = (Dali::Widget *)jarg1;
101495   arg2 = (Dali::Widget *)jarg2;
101496   if (!arg2) {
101497     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget const & type is null", 0);
101498     return 0;
101499   }
101500   {
101501     try {
101502       result = (Dali::Widget *) &(arg1)->operator =((Dali::Widget const &)*arg2);
101503     } catch (std::out_of_range& e) {
101504       {
101505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101506       };
101507     } catch (std::exception& e) {
101508       {
101509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101510       };
101511     } catch (...) {
101512       {
101513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101514       };
101515     }
101516   }
101517   jresult = (void *)result;
101518   return jresult;
101519 }
101520
101521
101522 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Widget(void * jarg1) {
101523   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
101524
101525   arg1 = (Dali::Widget *)jarg1;
101526   {
101527     try {
101528       delete arg1;
101529     } catch (std::out_of_range& e) {
101530       {
101531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101532       };
101533     } catch (std::exception& e) {
101534       {
101535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101536       };
101537     } catch (...) {
101538       {
101539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101540       };
101541     }
101542   }
101543 }
101544
101545
101546 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetImpl_New() {
101547   void * jresult ;
101548   SwigDirector_WidgetImpl* result;
101549   {
101550     try {
101551       result = new SwigDirector_WidgetImpl();
101552     } catch (std::out_of_range& e) {
101553       {
101554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101555       };
101556     } catch (std::exception& e) {
101557       {
101558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101559       };
101560     } catch (...) {
101561       {
101562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101563       };
101564     }
101565   }
101566   jresult = result;
101567   return jresult;
101568 }
101569
101570
101571 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreate(void * jarg1, char * jarg2, void * jarg3) {
101572   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101573   std::string *arg2 = 0 ;
101574   Dali::Window arg3 ;
101575   Dali::Window *argp3 ;
101576
101577   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101578   if (!jarg2) {
101579     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101580     return ;
101581   }
101582   std::string arg2_str(jarg2);
101583   arg2 = &arg2_str;
101584   argp3 = (Dali::Window *)jarg3;
101585   if (!argp3) {
101586     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
101587     return ;
101588   }
101589   arg3 = *argp3;
101590   {
101591     try {
101592       (arg1)->OnCreate((std::string const &)*arg2,arg3);
101593     } catch (std::out_of_range& e) {
101594       {
101595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101596       };
101597     } catch (std::exception& e) {
101598       {
101599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101600       };
101601     } catch (...) {
101602       {
101603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101604       };
101605     }
101606   }
101607 }
101608
101609 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, void * jarg3) {
101610   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101611   std::string *arg2 = 0 ;
101612   Dali::Window arg3 ;
101613   Dali::Window *argp3 ;
101614
101615   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101616   if (!jarg2) {
101617     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101618     return ;
101619   }
101620   std::string arg2_str(jarg2);
101621   arg2 = &arg2_str;
101622   argp3 = (Dali::Window *)jarg3;
101623   if (!argp3) {
101624     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
101625     return ;
101626   }
101627   arg3 = *argp3;
101628   {
101629     try {
101630       (arg1)->Dali::Internal::Adaptor::Widget::OnCreate((std::string const &)*arg2,arg3);
101631     } catch (std::out_of_range& e) {
101632       {
101633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101634       };
101635     } catch (std::exception& e) {
101636       {
101637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101638       };
101639     } catch (...) {
101640       {
101641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101642       };
101643     }
101644   }
101645 }
101646
101647
101648 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminate(void * jarg1, char * jarg2, int jarg3) {
101649   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101650   std::string *arg2 = 0 ;
101651   Dali::Widget::Termination arg3 ;
101652
101653   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101654   if (!jarg2) {
101655     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101656     return ;
101657   }
101658   std::string arg2_str(jarg2);
101659   arg2 = &arg2_str;
101660   arg3 = (Dali::Widget::Termination)jarg3;
101661   {
101662     try {
101663       (arg1)->OnTerminate((std::string const &)*arg2,arg3);
101664     } catch (std::out_of_range& e) {
101665       {
101666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101667       };
101668     } catch (std::exception& e) {
101669       {
101670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101671       };
101672     } catch (...) {
101673       {
101674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101675       };
101676     }
101677   }
101678 }
101679
101680 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
101681   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101682   std::string *arg2 = 0 ;
101683   Dali::Widget::Termination arg3 ;
101684
101685   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101686   if (!jarg2) {
101687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101688     return ;
101689   }
101690   std::string arg2_str(jarg2);
101691   arg2 = &arg2_str;
101692   arg3 = (Dali::Widget::Termination)jarg3;
101693   {
101694     try {
101695       (arg1)->Dali::Internal::Adaptor::Widget::OnTerminate((std::string const &)*arg2,arg3);
101696     } catch (std::out_of_range& e) {
101697       {
101698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101699       };
101700     } catch (std::exception& e) {
101701       {
101702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101703       };
101704     } catch (...) {
101705       {
101706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101707       };
101708     }
101709   }
101710 }
101711
101712
101713 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPause(void * jarg1) {
101714   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101715
101716   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101717   {
101718     try {
101719       (arg1)->OnPause();
101720     } catch (std::out_of_range& e) {
101721       {
101722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101723       };
101724     } catch (std::exception& e) {
101725       {
101726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101727       };
101728     } catch (...) {
101729       {
101730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101731       };
101732     }
101733   }
101734 }
101735
101736 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPauseSwigExplicitWidgetImpl(void * jarg1) {
101737   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101738
101739   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101740   {
101741     try {
101742       (arg1)->Dali::Internal::Adaptor::Widget::OnPause();
101743     } catch (std::out_of_range& e) {
101744       {
101745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101746       };
101747     } catch (std::exception& e) {
101748       {
101749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101750       };
101751     } catch (...) {
101752       {
101753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101754       };
101755     }
101756   }
101757 }
101758
101759
101760 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResume(void * jarg1) {
101761   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101762
101763   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101764   {
101765     try {
101766       (arg1)->OnResume();
101767     } catch (std::out_of_range& e) {
101768       {
101769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101770       };
101771     } catch (std::exception& e) {
101772       {
101773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101774       };
101775     } catch (...) {
101776       {
101777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101778       };
101779     }
101780   }
101781 }
101782
101783
101784 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResumeSwigExplicitWidgetImpl(void * jarg1) {
101785   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101786
101787   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101788   {
101789     try {
101790       (arg1)->Dali::Internal::Adaptor::Widget::OnResume();
101791     } catch (std::out_of_range& e) {
101792       {
101793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101794       };
101795     } catch (std::exception& e) {
101796       {
101797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101798       };
101799     } catch (...) {
101800       {
101801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101802       };
101803     }
101804   }
101805 }
101806
101807
101808 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResize(void * jarg1, void * jarg2) {
101809   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101810   Dali::Window arg2 ;
101811   Dali::Window *argp2 ;
101812
101813   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101814   argp2 = (Dali::Window *)jarg2;
101815   if (!argp2) {
101816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
101817     return ;
101818   }
101819   arg2 = *argp2;
101820   {
101821     try {
101822       (arg1)->OnResize(arg2);
101823     } catch (std::out_of_range& e) {
101824       {
101825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101826       };
101827     } catch (std::exception& e) {
101828       {
101829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101830       };
101831     } catch (...) {
101832       {
101833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101834       };
101835     }
101836   }
101837 }
101838
101839 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResizeSwigExplicitWidgetImpl(void * jarg1, void * jarg2) {
101840   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101841   Dali::Window arg2 ;
101842   Dali::Window *argp2 ;
101843
101844   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101845   argp2 = (Dali::Window *)jarg2;
101846   if (!argp2) {
101847     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
101848     return ;
101849   }
101850   arg2 = *argp2;
101851   {
101852     try {
101853       (arg1)->Dali::Internal::Adaptor::Widget::OnResize(arg2);
101854     } catch (std::out_of_range& e) {
101855       {
101856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101857       };
101858     } catch (std::exception& e) {
101859       {
101860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101861       };
101862     } catch (...) {
101863       {
101864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101865       };
101866     }
101867   }
101868 }
101869
101870
101871 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdate(void * jarg1, char * jarg2, int jarg3) {
101872   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101873   std::string *arg2 = 0 ;
101874   int arg3 ;
101875
101876   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101877   if (!jarg2) {
101878     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101879     return ;
101880   }
101881   std::string arg2_str(jarg2);
101882   arg2 = &arg2_str;
101883   arg3 = (int)jarg3;
101884   {
101885     try {
101886       (arg1)->OnUpdate((std::string const &)*arg2,arg3);
101887     } catch (std::out_of_range& e) {
101888       {
101889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101890       };
101891     } catch (std::exception& e) {
101892       {
101893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101894       };
101895     } catch (...) {
101896       {
101897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101898       };
101899     }
101900   }
101901 }
101902
101903 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
101904   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101905   std::string *arg2 = 0 ;
101906   int arg3 ;
101907
101908   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101909   if (!jarg2) {
101910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101911     return ;
101912   }
101913   std::string arg2_str(jarg2);
101914   arg2 = &arg2_str;
101915   arg3 = (int)jarg3;
101916   {
101917     try {
101918       (arg1)->Dali::Internal::Adaptor::Widget::OnUpdate((std::string const &)*arg2,arg3);
101919     } catch (std::out_of_range& e) {
101920       {
101921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101922       };
101923     } catch (std::exception& e) {
101924       {
101925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101926       };
101927     } catch (...) {
101928       {
101929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101930       };
101931     }
101932   }
101933 }
101934
101935
101936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
101937   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101938   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
101939   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
101940
101941   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101942   arg2 = (Dali::SlotObserver *)jarg2;
101943   arg3 = (Dali::CallbackBase *)jarg3;
101944   {
101945     try {
101946       (arg1)->SignalConnected(arg2,arg3);
101947     } catch (std::out_of_range& e) {
101948       {
101949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101950       };
101951     } catch (std::exception& e) {
101952       {
101953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101954       };
101955     } catch (...) {
101956       {
101957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101958       };
101959     }
101960   }
101961 }
101962
101963 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
101964   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101965   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
101966   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
101967
101968   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101969   arg2 = (Dali::SlotObserver *)jarg2;
101970   arg3 = (Dali::CallbackBase *)jarg3;
101971   {
101972     try {
101973       (arg1)->Dali::Internal::Adaptor::Widget::SignalConnected(arg2,arg3);
101974     } catch (std::out_of_range& e) {
101975       {
101976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101977       };
101978     } catch (std::exception& e) {
101979       {
101980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101981       };
101982     } catch (...) {
101983       {
101984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101985       };
101986     }
101987   }
101988 }
101989
101990
101991 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
101992   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101993   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
101994   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
101995
101996   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101997   arg2 = (Dali::SlotObserver *)jarg2;
101998   arg3 = (Dali::CallbackBase *)jarg3;
101999   {
102000     try {
102001       (arg1)->SignalDisconnected(arg2,arg3);
102002     } catch (std::out_of_range& e) {
102003       {
102004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102005       };
102006     } catch (std::exception& e) {
102007       {
102008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102009       };
102010     } catch (...) {
102011       {
102012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102013       };
102014     }
102015   }
102016 }
102017
102018 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
102019   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
102020   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
102021   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
102022
102023   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
102024   arg2 = (Dali::SlotObserver *)jarg2;
102025   arg3 = (Dali::CallbackBase *)jarg3;
102026   {
102027     try {
102028       (arg1)->Dali::Internal::Adaptor::Widget::SignalDisconnected(arg2,arg3);
102029     } catch (std::out_of_range& e) {
102030       {
102031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102032       };
102033     } catch (std::exception& e) {
102034       {
102035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102036       };
102037     } catch (...) {
102038       {
102039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102040       };
102041     }
102042   }
102043 }
102044
102045 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetContentInfo(void * jarg1, char * jarg2) {
102046   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
102047   std::string *arg2 = 0 ;
102048
102049   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
102050   if (!jarg2) {
102051     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102052     return ;
102053   }
102054   std::string arg2_str(jarg2);
102055   arg2 = &arg2_str;
102056   {
102057     try {
102058       (arg1)->SetContentInfo((std::string const &)*arg2);
102059     } catch (std::out_of_range& e) {
102060       {
102061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102062       };
102063     } catch (std::exception& e) {
102064       {
102065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102066       };
102067     } catch (...) {
102068       {
102069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102070       };
102071     }
102072   }
102073 }
102074
102075
102076 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetImpl(void * jarg1, void * jarg2) {
102077   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
102078   Dali::Internal::Adaptor::Widget::Impl *arg2 = (Dali::Internal::Adaptor::Widget::Impl *) 0 ;
102079
102080   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
102081   arg2 = (Dali::Internal::Adaptor::Widget::Impl *)jarg2;
102082   {
102083     try {
102084       (arg1)->SetImpl(arg2);
102085     } catch (std::out_of_range& e) {
102086       {
102087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102088       };
102089     } catch (std::exception& e) {
102090       {
102091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102092       };
102093     } catch (...) {
102094       {
102095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102096       };
102097     }
102098   }
102099 }
102100
102101 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) {
102102
102103   SwigDirector_WidgetImpl *director = static_cast<SwigDirector_WidgetImpl *>(objarg);
102104   if (director) {
102105     director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5, callback6, callback7);
102106   }
102107 }
102108
102109 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_GetImplementation__SWIG_0(void * jarg1) {
102110   void * jresult ;
102111   Dali::Widget *arg1 = 0 ;
102112   SwigDirector_WidgetImpl *result = 0 ;
102113
102114   arg1 = (Dali::Widget *)jarg1;
102115   if (!arg1) {
102116     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget & type is null", 0);
102117     return 0;
102118   }
102119   {
102120     try {
102121       result = (SwigDirector_WidgetImpl *) &Dali::Internal::Adaptor::GetImplementation(*arg1);
102122     } catch (std::out_of_range& e) {
102123       {
102124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102125       };
102126     } catch (std::exception& e) {
102127       {
102128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102129       };
102130     } catch (...) {
102131       {
102132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102133       };
102134     }
102135   }
102136
102137   jresult = (void *)result;
102138   return jresult;
102139 }
102140
102141
102142 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_New(int jarg1, char * jarg2, char * jarg3) {
102143   void * jresult ;
102144   int *arg1 = (int *) 0 ;
102145   char ***arg2 ;
102146   std::string *arg3 = 0 ;
102147   Dali::WidgetApplication result;
102148   {
102149     int index = 0;
102150     int length = 0;
102151     char *retPtr;
102152     char *nextPtr;
102153     argWidgetC = jarg1;
102154     argWidgetV = new char*[jarg1 + 1];
102155
102156     retPtr = strtok_r( jarg2, " ", &nextPtr);
102157     if( retPtr )
102158     {
102159       length = strlen(retPtr);
102160     }
102161     argWidgetV[index] = new char[length + 1];
102162     if( retPtr )
102163     {
102164       strncpy(argWidgetV[index], retPtr, length);
102165     }
102166     argWidgetV[index][length] = '\0';
102167     index++;
102168
102169     while (index < jarg1)
102170     {
102171       length = 0;
102172       retPtr = strtok_r(NULL, " ", &nextPtr);
102173       if( retPtr )
102174       {
102175         length = strlen(retPtr);
102176       }
102177       argWidgetV[index] = new char[length + 1];
102178       if( retPtr )
102179       {
102180         strncpy(argWidgetV[index], retPtr, length);
102181       }
102182       argWidgetV[index][length] = '\0';
102183       index++;
102184     }
102185
102186     argWidgetV[jarg1] = NULL;
102187     argWidgetC = jarg1;
102188
102189     arg1 = &argWidgetC;
102190     arg2 = &argWidgetV;
102191   }
102192
102193   if (!jarg3) {
102194     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102195     return 0;
102196   }
102197   std::string arg3_str(jarg3);
102198   arg3 = &arg3_str;
102199   {
102200     try {
102201       result = Dali::WidgetApplication::New(arg1,arg2,(std::string const &)*arg3);
102202     } catch (std::out_of_range& e) {
102203       {
102204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102205       };
102206     } catch (std::exception& e) {
102207       {
102208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102209       };
102210     } catch (...) {
102211       {
102212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102213       };
102214     }
102215   }
102216   jresult = new Dali::WidgetApplication((const Dali::WidgetApplication &)result);
102217
102218   return jresult;
102219 }
102220
102221
102222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_0() {
102223   void * jresult ;
102224   Dali::WidgetApplication *result = 0 ;
102225
102226   {
102227     try {
102228       result = (Dali::WidgetApplication *)new Dali::WidgetApplication();
102229     } catch (std::out_of_range& e) {
102230       {
102231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102232       };
102233     } catch (std::exception& e) {
102234       {
102235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102236       };
102237     } catch (...) {
102238       {
102239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102240       };
102241     }
102242   }
102243   jresult = (void *)result;
102244   return jresult;
102245 }
102246
102247
102248 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_1(void * jarg1) {
102249   void * jresult ;
102250   Dali::WidgetApplication *arg1 = 0 ;
102251   Dali::WidgetApplication *result = 0 ;
102252
102253   arg1 = (Dali::WidgetApplication *)jarg1;
102254   if (!arg1) {
102255     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
102256     return 0;
102257   }
102258   {
102259     try {
102260       result = (Dali::WidgetApplication *)new Dali::WidgetApplication((Dali::WidgetApplication const &)*arg1);
102261     } catch (std::out_of_range& e) {
102262       {
102263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102264       };
102265     } catch (std::exception& e) {
102266       {
102267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102268       };
102269     } catch (...) {
102270       {
102271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102272       };
102273     }
102274   }
102275   jresult = (void *)result;
102276   return jresult;
102277 }
102278
102279
102280 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_Assign(void * jarg1, void * jarg2) {
102281   void * jresult ;
102282   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
102283   Dali::WidgetApplication *arg2 = 0 ;
102284   Dali::WidgetApplication *result = 0 ;
102285
102286   arg1 = (Dali::WidgetApplication *)jarg1;
102287   arg2 = (Dali::WidgetApplication *)jarg2;
102288   if (!arg2) {
102289     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
102290     return 0;
102291   }
102292   {
102293     try {
102294       result = (Dali::WidgetApplication *) &(arg1)->operator =((Dali::WidgetApplication const &)*arg2);
102295     } catch (std::out_of_range& e) {
102296       {
102297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102298       };
102299     } catch (std::exception& e) {
102300       {
102301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102302       };
102303     } catch (...) {
102304       {
102305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102306       };
102307     }
102308   }
102309   jresult = (void *)result;
102310   return jresult;
102311 }
102312
102313
102314 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WidgetApplication(void * jarg1) {
102315   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
102316
102317   arg1 = (Dali::WidgetApplication *)jarg1;
102318   {
102319     try {
102320       delete arg1;
102321       if( argWidgetV )
102322       {
102323         // free string data
102324         for( int i=0; i < argWidgetC+1; i++)
102325         {
102326           delete [] argWidgetV[i];
102327         }
102328         delete [] argWidgetV;
102329       }
102330     } catch (std::out_of_range& e) {
102331       {
102332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102333       };
102334     } catch (std::exception& e) {
102335       {
102336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102337       };
102338     } catch (...) {
102339       {
102340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102341       };
102342     }
102343   }
102344 }
102345
102346
102347 typedef Dali::Widget*(SWIGSTDCALL *CSharpCreateWidgetFunction)(const std::string&);
102348 CSharpCreateWidgetFunction _CSharpCreateWidgetFunction = NULL;
102349
102350 static Dali::Widget SWIGSTDCALL WidgetFactoryFunction( const std::string& widgetName )
102351 {
102352   Widget* widget = _CSharpCreateWidgetFunction( widgetName.c_str() );
102353   return *widget;
102354 }
102355
102356 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetApplication_RegisterWidgetCreatingFunction(void * jarg1, char** jarg2, void * jarg3) {
102357   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
102358   std::string *arg2 = 0 ;
102359
102360   arg1 = (Dali::WidgetApplication *)jarg1;
102361   if (!jarg2) {
102362     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102363     return ;
102364   }
102365   std::string arg2_str(*jarg2);
102366   arg2 = &arg2_str;
102367
102368   if(!_CSharpCreateWidgetFunction)
102369   {
102370     _CSharpCreateWidgetFunction = (Dali::Widget*(*)(const std::string&))jarg3;
102371   }
102372
102373   {
102374     try {
102375       (arg1)->RegisterWidgetCreatingFunction((std::string const &)*arg2, WidgetFactoryFunction);
102376     } catch (std::out_of_range& e) {
102377       {
102378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102379       };
102380     } catch (std::exception& e) {
102381       {
102382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102383       };
102384     } catch (...) {
102385       {
102386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102387       };
102388     }
102389   }
102390
102391   //Typemap argout in c++ file.
102392   //This will convert c++ string to c# string
102393   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
102394 }
102395
102396
102397 //for PixelBuffer and ImageLoading
102398
102399 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelBuffer_SWIGUpcast(Dali::Devel::PixelBuffer *jarg1) {
102400     return (Dali::BaseHandle *)jarg1;
102401 }
102402
102403 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_New(unsigned int jarg1, unsigned int jarg2, int jarg3) {
102404   void * jresult ;
102405   unsigned int arg1 ;
102406   unsigned int arg2 ;
102407   Dali::Pixel::Format arg3 ;
102408   Dali::Devel::PixelBuffer result;
102409
102410   arg1 = (unsigned int)jarg1;
102411   arg2 = (unsigned int)jarg2;
102412   arg3 = (Dali::Pixel::Format)jarg3;
102413   {
102414     try {
102415       result = Dali::Devel::PixelBuffer::New(arg1,arg2,arg3);
102416     } catch (std::out_of_range& e) {
102417       {
102418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102419       };
102420     } catch (std::exception& e) {
102421       {
102422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102423       };
102424     } catch (...) {
102425       {
102426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102427       };
102428     }
102429   }
102430   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102431   return jresult;
102432 }
102433
102434
102435 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_0() {
102436   void * jresult ;
102437   Dali::Devel::PixelBuffer *result = 0 ;
102438
102439   {
102440     try {
102441       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer();
102442     } catch (std::out_of_range& e) {
102443       {
102444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102445       };
102446     } catch (std::exception& e) {
102447       {
102448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102449       };
102450     } catch (...) {
102451       {
102452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102453       };
102454     }
102455   }
102456   jresult = (void *)result;
102457   return jresult;
102458 }
102459
102460
102461 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelBuffer(void * jarg1) {
102462   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102463
102464   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102465   {
102466     try {
102467       delete arg1;
102468     } catch (std::out_of_range& e) {
102469       {
102470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102471       };
102472     } catch (std::exception& e) {
102473       {
102474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102475       };
102476     } catch (...) {
102477       {
102478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102479       };
102480     }
102481   }
102482 }
102483
102484
102485 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_1(void * jarg1) {
102486   void * jresult ;
102487   Dali::Devel::PixelBuffer *arg1 = 0 ;
102488   Dali::Devel::PixelBuffer *result = 0 ;
102489
102490   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102491   if (!arg1) {
102492     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
102493     return 0;
102494   }
102495   {
102496     try {
102497       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer((Dali::Devel::PixelBuffer const &)*arg1);
102498     } catch (std::out_of_range& e) {
102499       {
102500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102501       };
102502     } catch (std::exception& e) {
102503       {
102504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102505       };
102506     } catch (...) {
102507       {
102508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102509       };
102510     }
102511   }
102512   jresult = (void *)result;
102513   return jresult;
102514 }
102515
102516
102517 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Assign(void * jarg1, void * jarg2) {
102518   void * jresult ;
102519   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102520   Dali::Devel::PixelBuffer *arg2 = 0 ;
102521   Dali::Devel::PixelBuffer *result = 0 ;
102522
102523   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102524   arg2 = (Dali::Devel::PixelBuffer *)jarg2;
102525   if (!arg2) {
102526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
102527     return 0;
102528   }
102529   {
102530     try {
102531       result = (Dali::Devel::PixelBuffer *) &(arg1)->operator =((Dali::Devel::PixelBuffer const &)*arg2);
102532     } catch (std::out_of_range& e) {
102533       {
102534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102535       };
102536     } catch (std::exception& e) {
102537       {
102538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102539       };
102540     } catch (...) {
102541       {
102542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102543       };
102544     }
102545   }
102546   jresult = (void *)result;
102547   return jresult;
102548 }
102549
102550
102551 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Convert(void * jarg1) {
102552   void * jresult ;
102553   Dali::Devel::PixelBuffer *arg1 = 0 ;
102554   Dali::PixelData result;
102555
102556   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102557   if (!arg1) {
102558     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer & type is null", 0);
102559     return 0;
102560   }
102561   {
102562     try {
102563       result = Dali::Devel::PixelBuffer::Convert(*arg1);
102564     } catch (std::out_of_range& e) {
102565       {
102566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102567       };
102568     } catch (std::exception& e) {
102569       {
102570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102571       };
102572     } catch (...) {
102573       {
102574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102575       };
102576     }
102577   }
102578   jresult = new Dali::PixelData((const Dali::PixelData &)result);
102579   return jresult;
102580 }
102581
102582
102583 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_CreatePixelData(void * jarg1) {
102584   void * jresult ;
102585   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102586   Dali::PixelData result;
102587
102588   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102589   {
102590     try {
102591       result = ((Dali::Devel::PixelBuffer const *)arg1)->CreatePixelData();
102592     } catch (std::out_of_range& e) {
102593       {
102594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102595       };
102596     } catch (std::exception& e) {
102597       {
102598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102599       };
102600     } catch (...) {
102601       {
102602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102603       };
102604     }
102605   }
102606   jresult = new Dali::PixelData((const Dali::PixelData &)result);
102607   return jresult;
102608 }
102609
102610
102611 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_GetBuffer(void * jarg1) {
102612   void * jresult ;
102613   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102614   unsigned char *result = 0 ;
102615
102616   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102617   {
102618     try {
102619       result = (unsigned char *)(arg1)->GetBuffer();
102620     } catch (std::out_of_range& e) {
102621       {
102622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102623       };
102624     } catch (std::exception& e) {
102625       {
102626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102627       };
102628     } catch (...) {
102629       {
102630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102631       };
102632     }
102633   }
102634   jresult = (void *)result;
102635   return jresult;
102636 }
102637
102638
102639 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetWidth(void * jarg1) {
102640   unsigned int jresult ;
102641   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102642   unsigned int result;
102643
102644   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102645   {
102646     try {
102647       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetWidth();
102648     } catch (std::out_of_range& e) {
102649       {
102650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102651       };
102652     } catch (std::exception& e) {
102653       {
102654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102655       };
102656     } catch (...) {
102657       {
102658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102659       };
102660     }
102661   }
102662   jresult = result;
102663   return jresult;
102664 }
102665
102666
102667 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetHeight(void * jarg1) {
102668   unsigned int jresult ;
102669   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102670   unsigned int result;
102671
102672   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102673   {
102674     try {
102675       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetHeight();
102676     } catch (std::out_of_range& e) {
102677       {
102678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102679       };
102680     } catch (std::exception& e) {
102681       {
102682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102683       };
102684     } catch (...) {
102685       {
102686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102687       };
102688     }
102689   }
102690   jresult = result;
102691   return jresult;
102692 }
102693
102694
102695 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetPixelFormat(void * jarg1) {
102696   int jresult ;
102697   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102698   Dali::Pixel::Format result;
102699
102700   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102701   {
102702     try {
102703       result = (Dali::Pixel::Format)((Dali::Devel::PixelBuffer const *)arg1)->GetPixelFormat();
102704     } catch (std::out_of_range& e) {
102705       {
102706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102707       };
102708     } catch (std::exception& e) {
102709       {
102710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102711       };
102712     } catch (...) {
102713       {
102714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102715       };
102716     }
102717   }
102718   jresult = (int)result;
102719   return jresult;
102720 }
102721
102722
102723 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_0(void * jarg1, void * jarg2, float jarg3, unsigned int jarg4) {
102724   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102725   Dali::Devel::PixelBuffer arg2 ;
102726   float arg3 ;
102727   bool arg4 ;
102728   Dali::Devel::PixelBuffer *argp2 ;
102729
102730   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102731   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
102732   if (!argp2) {
102733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
102734     return ;
102735   }
102736   arg2 = *argp2;
102737   arg3 = (float)jarg3;
102738   arg4 = jarg4 ? true : false;
102739   {
102740     try {
102741       (arg1)->ApplyMask(arg2,arg3,arg4);
102742     } catch (std::out_of_range& e) {
102743       {
102744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102745       };
102746     } catch (std::exception& e) {
102747       {
102748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102749       };
102750     } catch (...) {
102751       {
102752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102753       };
102754     }
102755   }
102756 }
102757
102758
102759 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
102760   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102761   Dali::Devel::PixelBuffer arg2 ;
102762   float arg3 ;
102763   Dali::Devel::PixelBuffer *argp2 ;
102764
102765   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102766   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
102767   if (!argp2) {
102768     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
102769     return ;
102770   }
102771   arg2 = *argp2;
102772   arg3 = (float)jarg3;
102773   {
102774     try {
102775       (arg1)->ApplyMask(arg2,arg3);
102776     } catch (std::out_of_range& e) {
102777       {
102778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102779       };
102780     } catch (std::exception& e) {
102781       {
102782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102783       };
102784     } catch (...) {
102785       {
102786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102787       };
102788     }
102789   }
102790 }
102791
102792
102793 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_2(void * jarg1, void * jarg2) {
102794   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102795   Dali::Devel::PixelBuffer arg2 ;
102796   Dali::Devel::PixelBuffer *argp2 ;
102797
102798   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102799   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
102800   if (!argp2) {
102801     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
102802     return ;
102803   }
102804   arg2 = *argp2;
102805   {
102806     try {
102807       (arg1)->ApplyMask(arg2);
102808     } catch (std::out_of_range& e) {
102809       {
102810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102811       };
102812     } catch (std::exception& e) {
102813       {
102814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102815       };
102816     } catch (...) {
102817       {
102818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102819       };
102820     }
102821   }
102822 }
102823
102824
102825 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyGaussianBlur(void * jarg1, float jarg2) {
102826   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102827   float arg2 ;
102828
102829   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102830   arg2 = (float)jarg2;
102831   {
102832     try {
102833       (arg1)->ApplyGaussianBlur(arg2);
102834     } catch (std::out_of_range& e) {
102835       {
102836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102837       };
102838     } catch (std::exception& e) {
102839       {
102840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102841       };
102842     } catch (...) {
102843       {
102844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102845       };
102846     }
102847   }
102848 }
102849
102850
102851 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Crop(void * jarg1, unsigned short jarg2, unsigned short jarg3, unsigned short jarg4, unsigned short jarg5) {
102852   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102853   uint16_t arg2 ;
102854   uint16_t arg3 ;
102855   uint16_t arg4 ;
102856   uint16_t arg5 ;
102857
102858   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102859   arg2 = (uint16_t)jarg2;
102860   arg3 = (uint16_t)jarg3;
102861   arg4 = (uint16_t)jarg4;
102862   arg5 = (uint16_t)jarg5;
102863   {
102864     try {
102865       (arg1)->Crop(arg2,arg3,arg4,arg5);
102866     } catch (std::out_of_range& e) {
102867       {
102868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102869       };
102870     } catch (std::exception& e) {
102871       {
102872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102873       };
102874     } catch (...) {
102875       {
102876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102877       };
102878     }
102879   }
102880 }
102881
102882
102883 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Resize(void * jarg1, unsigned short jarg2, unsigned short jarg3) {
102884   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102885   uint16_t arg2 ;
102886   uint16_t arg3 ;
102887
102888   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102889   arg2 = (uint16_t)jarg2;
102890   arg3 = (uint16_t)jarg3;
102891   {
102892     try {
102893       (arg1)->Resize(arg2,arg3);
102894     } catch (std::out_of_range& e) {
102895       {
102896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102897       };
102898     } catch (std::exception& e) {
102899       {
102900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102901       };
102902     } catch (...) {
102903       {
102904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102905       };
102906     }
102907   }
102908 }
102909
102910
102911 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_2(void * jarg1) {
102912   void * jresult ;
102913   Dali::Internal::Adaptor::PixelBuffer *arg1 = (Dali::Internal::Adaptor::PixelBuffer *) 0 ;
102914   Dali::Devel::PixelBuffer *result = 0 ;
102915
102916   arg1 = (Dali::Internal::Adaptor::PixelBuffer *)jarg1;
102917   {
102918     try {
102919       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer(arg1);
102920     } catch (std::out_of_range& e) {
102921       {
102922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102923       };
102924     } catch (std::exception& e) {
102925       {
102926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102927       };
102928     } catch (...) {
102929       {
102930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102931       };
102932     }
102933   }
102934   jresult = (void *)result;
102935   return jresult;
102936 }
102937
102938
102939 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
102940   void * jresult ;
102941   std::string *arg1 = 0 ;
102942   Dali::ImageDimensions arg2 ;
102943   Dali::FittingMode::Type arg3 ;
102944   Dali::SamplingMode::Type arg4 ;
102945   bool arg5 ;
102946   Dali::ImageDimensions *argp2 ;
102947   Dali::Devel::PixelBuffer result;
102948
102949   if (!jarg1) {
102950     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102951     return 0;
102952   }
102953   std::string arg1_str(jarg1);
102954   arg1 = &arg1_str;
102955   argp2 = (Dali::ImageDimensions *)jarg2;
102956   if (!argp2) {
102957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102958     return 0;
102959   }
102960   arg2 = *argp2;
102961   arg3 = (Dali::FittingMode::Type)jarg3;
102962   arg4 = (Dali::SamplingMode::Type)jarg4;
102963   arg5 = jarg5 ? true : false;
102964   {
102965     try {
102966       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4,arg5);
102967     } catch (std::out_of_range& e) {
102968       {
102969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102970       };
102971     } catch (std::exception& e) {
102972       {
102973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102974       };
102975     } catch (...) {
102976       {
102977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102978       };
102979     }
102980   }
102981   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102982
102983   return jresult;
102984 }
102985
102986
102987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
102988   void * jresult ;
102989   std::string *arg1 = 0 ;
102990   Dali::ImageDimensions arg2 ;
102991   Dali::FittingMode::Type arg3 ;
102992   Dali::SamplingMode::Type arg4 ;
102993   Dali::ImageDimensions *argp2 ;
102994   Dali::Devel::PixelBuffer result;
102995
102996   if (!jarg1) {
102997     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102998     return 0;
102999   }
103000   std::string arg1_str(jarg1);
103001   arg1 = &arg1_str;
103002   argp2 = (Dali::ImageDimensions *)jarg2;
103003   if (!argp2) {
103004     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103005     return 0;
103006   }
103007   arg2 = *argp2;
103008   arg3 = (Dali::FittingMode::Type)jarg3;
103009   arg4 = (Dali::SamplingMode::Type)jarg4;
103010   {
103011     try {
103012       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4);
103013     } catch (std::out_of_range& e) {
103014       {
103015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103016       };
103017     } catch (std::exception& e) {
103018       {
103019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103020       };
103021     } catch (...) {
103022       {
103023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103024       };
103025     }
103026   }
103027   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103028
103029   return jresult;
103030 }
103031
103032
103033 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
103034   void * jresult ;
103035   std::string *arg1 = 0 ;
103036   Dali::ImageDimensions arg2 ;
103037   Dali::FittingMode::Type arg3 ;
103038   Dali::ImageDimensions *argp2 ;
103039   Dali::Devel::PixelBuffer result;
103040
103041   if (!jarg1) {
103042     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103043     return 0;
103044   }
103045   std::string arg1_str(jarg1);
103046   arg1 = &arg1_str;
103047   argp2 = (Dali::ImageDimensions *)jarg2;
103048   if (!argp2) {
103049     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103050     return 0;
103051   }
103052   arg2 = *argp2;
103053   arg3 = (Dali::FittingMode::Type)jarg3;
103054   {
103055     try {
103056       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3);
103057     } catch (std::out_of_range& e) {
103058       {
103059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103060       };
103061     } catch (std::exception& e) {
103062       {
103063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103064       };
103065     } catch (...) {
103066       {
103067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103068       };
103069     }
103070   }
103071   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103072
103073   return jresult;
103074 }
103075
103076
103077 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_3(char * jarg1, void * jarg2) {
103078   void * jresult ;
103079   std::string *arg1 = 0 ;
103080   Dali::ImageDimensions arg2 ;
103081   Dali::ImageDimensions *argp2 ;
103082   Dali::Devel::PixelBuffer result;
103083
103084   if (!jarg1) {
103085     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103086     return 0;
103087   }
103088   std::string arg1_str(jarg1);
103089   arg1 = &arg1_str;
103090   argp2 = (Dali::ImageDimensions *)jarg2;
103091   if (!argp2) {
103092     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103093     return 0;
103094   }
103095   arg2 = *argp2;
103096   {
103097     try {
103098       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2);
103099     } catch (std::out_of_range& e) {
103100       {
103101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103102       };
103103     } catch (std::exception& e) {
103104       {
103105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103106       };
103107     } catch (...) {
103108       {
103109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103110       };
103111     }
103112   }
103113   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103114
103115   return jresult;
103116 }
103117
103118
103119 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_4(char * jarg1) {
103120   void * jresult ;
103121   std::string *arg1 = 0 ;
103122   Dali::Devel::PixelBuffer result;
103123
103124   if (!jarg1) {
103125     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103126     return 0;
103127   }
103128   std::string arg1_str(jarg1);
103129   arg1 = &arg1_str;
103130   {
103131     try {
103132       result = Dali::LoadImageFromFile((std::string const &)*arg1);
103133     } catch (std::out_of_range& e) {
103134       {
103135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103136       };
103137     } catch (std::exception& e) {
103138       {
103139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103140       };
103141     } catch (...) {
103142       {
103143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103144       };
103145     }
103146   }
103147   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103148
103149   return jresult;
103150 }
103151
103152
103153 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
103154   void * jresult ;
103155   std::string *arg1 = 0 ;
103156   Dali::ImageDimensions arg2 ;
103157   Dali::FittingMode::Type arg3 ;
103158   Dali::SamplingMode::Type arg4 ;
103159   bool arg5 ;
103160   Dali::ImageDimensions *argp2 ;
103161   Dali::ImageDimensions result;
103162
103163   if (!jarg1) {
103164     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103165     return 0;
103166   }
103167   std::string arg1_str(jarg1);
103168   arg1 = &arg1_str;
103169   argp2 = (Dali::ImageDimensions *)jarg2;
103170   if (!argp2) {
103171     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103172     return 0;
103173   }
103174   arg2 = *argp2;
103175   arg3 = (Dali::FittingMode::Type)jarg3;
103176   arg4 = (Dali::SamplingMode::Type)jarg4;
103177   arg5 = jarg5 ? true : false;
103178   {
103179     try {
103180       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4,arg5);
103181     } catch (std::out_of_range& e) {
103182       {
103183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103184       };
103185     } catch (std::exception& e) {
103186       {
103187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103188       };
103189     } catch (...) {
103190       {
103191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103192       };
103193     }
103194   }
103195   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
103196
103197   return jresult;
103198 }
103199
103200
103201 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
103202   void * jresult ;
103203   std::string *arg1 = 0 ;
103204   Dali::ImageDimensions arg2 ;
103205   Dali::FittingMode::Type arg3 ;
103206   Dali::SamplingMode::Type arg4 ;
103207   Dali::ImageDimensions *argp2 ;
103208   Dali::ImageDimensions result;
103209
103210   if (!jarg1) {
103211     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103212     return 0;
103213   }
103214   std::string arg1_str(jarg1);
103215   arg1 = &arg1_str;
103216   argp2 = (Dali::ImageDimensions *)jarg2;
103217   if (!argp2) {
103218     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103219     return 0;
103220   }
103221   arg2 = *argp2;
103222   arg3 = (Dali::FittingMode::Type)jarg3;
103223   arg4 = (Dali::SamplingMode::Type)jarg4;
103224   {
103225     try {
103226       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4);
103227     } catch (std::out_of_range& e) {
103228       {
103229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103230       };
103231     } catch (std::exception& e) {
103232       {
103233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103234       };
103235     } catch (...) {
103236       {
103237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103238       };
103239     }
103240   }
103241   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
103242
103243   return jresult;
103244 }
103245
103246
103247 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
103248   void * jresult ;
103249   std::string *arg1 = 0 ;
103250   Dali::ImageDimensions arg2 ;
103251   Dali::FittingMode::Type arg3 ;
103252   Dali::ImageDimensions *argp2 ;
103253   Dali::ImageDimensions result;
103254
103255   if (!jarg1) {
103256     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103257     return 0;
103258   }
103259   std::string arg1_str(jarg1);
103260   arg1 = &arg1_str;
103261   argp2 = (Dali::ImageDimensions *)jarg2;
103262   if (!argp2) {
103263     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103264     return 0;
103265   }
103266   arg2 = *argp2;
103267   arg3 = (Dali::FittingMode::Type)jarg3;
103268   {
103269     try {
103270       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3);
103271     } catch (std::out_of_range& e) {
103272       {
103273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103274       };
103275     } catch (std::exception& e) {
103276       {
103277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103278       };
103279     } catch (...) {
103280       {
103281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103282       };
103283     }
103284   }
103285   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
103286
103287   return jresult;
103288 }
103289
103290
103291 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_3(char * jarg1, void * jarg2) {
103292   void * jresult ;
103293   std::string *arg1 = 0 ;
103294   Dali::ImageDimensions arg2 ;
103295   Dali::ImageDimensions *argp2 ;
103296   Dali::ImageDimensions result;
103297
103298   if (!jarg1) {
103299     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103300     return 0;
103301   }
103302   std::string arg1_str(jarg1);
103303   arg1 = &arg1_str;
103304   argp2 = (Dali::ImageDimensions *)jarg2;
103305   if (!argp2) {
103306     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103307     return 0;
103308   }
103309   arg2 = *argp2;
103310   {
103311     try {
103312       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2);
103313     } catch (std::out_of_range& e) {
103314       {
103315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103316       };
103317     } catch (std::exception& e) {
103318       {
103319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103320       };
103321     } catch (...) {
103322       {
103323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103324       };
103325     }
103326   }
103327   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
103328
103329   return jresult;
103330 }
103331
103332
103333 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_4(char * jarg1) {
103334   void * jresult ;
103335   std::string *arg1 = 0 ;
103336   Dali::ImageDimensions result;
103337
103338   if (!jarg1) {
103339     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103340     return 0;
103341   }
103342   std::string arg1_str(jarg1);
103343   arg1 = &arg1_str;
103344   {
103345     try {
103346       result = Dali::GetClosestImageSize((std::string const &)*arg1);
103347     } catch (std::out_of_range& e) {
103348       {
103349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103350       };
103351     } catch (std::exception& e) {
103352       {
103353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103354       };
103355     } catch (...) {
103356       {
103357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103358       };
103359     }
103360   }
103361   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
103362
103363   return jresult;
103364 }
103365
103366
103367 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
103368   void * jresult ;
103369   std::string *arg1 = 0 ;
103370   Dali::ImageDimensions arg2 ;
103371   Dali::FittingMode::Type arg3 ;
103372   Dali::SamplingMode::Type arg4 ;
103373   bool arg5 ;
103374   Dali::ImageDimensions *argp2 ;
103375   Dali::Devel::PixelBuffer result;
103376
103377   if (!jarg1) {
103378     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103379     return 0;
103380   }
103381   std::string arg1_str(jarg1);
103382   arg1 = &arg1_str;
103383   argp2 = (Dali::ImageDimensions *)jarg2;
103384   if (!argp2) {
103385     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103386     return 0;
103387   }
103388   arg2 = *argp2;
103389   arg3 = (Dali::FittingMode::Type)jarg3;
103390   arg4 = (Dali::SamplingMode::Type)jarg4;
103391   arg5 = jarg5 ? true : false;
103392   {
103393     try {
103394       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4,arg5);
103395     } catch (std::out_of_range& e) {
103396       {
103397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103398       };
103399     } catch (std::exception& e) {
103400       {
103401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103402       };
103403     } catch (...) {
103404       {
103405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103406       };
103407     }
103408   }
103409   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103410
103411   return jresult;
103412 }
103413
103414
103415 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
103416   void * jresult ;
103417   std::string *arg1 = 0 ;
103418   Dali::ImageDimensions arg2 ;
103419   Dali::FittingMode::Type arg3 ;
103420   Dali::SamplingMode::Type arg4 ;
103421   Dali::ImageDimensions *argp2 ;
103422   Dali::Devel::PixelBuffer result;
103423
103424   if (!jarg1) {
103425     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103426     return 0;
103427   }
103428   std::string arg1_str(jarg1);
103429   arg1 = &arg1_str;
103430   argp2 = (Dali::ImageDimensions *)jarg2;
103431   if (!argp2) {
103432     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103433     return 0;
103434   }
103435   arg2 = *argp2;
103436   arg3 = (Dali::FittingMode::Type)jarg3;
103437   arg4 = (Dali::SamplingMode::Type)jarg4;
103438   {
103439     try {
103440       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4);
103441     } catch (std::out_of_range& e) {
103442       {
103443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103444       };
103445     } catch (std::exception& e) {
103446       {
103447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103448       };
103449     } catch (...) {
103450       {
103451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103452       };
103453     }
103454   }
103455   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103456
103457   return jresult;
103458 }
103459
103460
103461 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
103462   void * jresult ;
103463   std::string *arg1 = 0 ;
103464   Dali::ImageDimensions arg2 ;
103465   Dali::FittingMode::Type arg3 ;
103466   Dali::ImageDimensions *argp2 ;
103467   Dali::Devel::PixelBuffer result;
103468
103469   if (!jarg1) {
103470     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103471     return 0;
103472   }
103473   std::string arg1_str(jarg1);
103474   arg1 = &arg1_str;
103475   argp2 = (Dali::ImageDimensions *)jarg2;
103476   if (!argp2) {
103477     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103478     return 0;
103479   }
103480   arg2 = *argp2;
103481   arg3 = (Dali::FittingMode::Type)jarg3;
103482   {
103483     try {
103484       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3);
103485     } catch (std::out_of_range& e) {
103486       {
103487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103488       };
103489     } catch (std::exception& e) {
103490       {
103491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103492       };
103493     } catch (...) {
103494       {
103495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103496       };
103497     }
103498   }
103499   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103500
103501   return jresult;
103502 }
103503
103504
103505 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_3(char * jarg1, void * jarg2) {
103506   void * jresult ;
103507   std::string *arg1 = 0 ;
103508   Dali::ImageDimensions arg2 ;
103509   Dali::ImageDimensions *argp2 ;
103510   Dali::Devel::PixelBuffer result;
103511
103512   if (!jarg1) {
103513     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103514     return 0;
103515   }
103516   std::string arg1_str(jarg1);
103517   arg1 = &arg1_str;
103518   argp2 = (Dali::ImageDimensions *)jarg2;
103519   if (!argp2) {
103520     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103521     return 0;
103522   }
103523   arg2 = *argp2;
103524   {
103525     try {
103526       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2);
103527     } catch (std::out_of_range& e) {
103528       {
103529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103530       };
103531     } catch (std::exception& e) {
103532       {
103533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103534       };
103535     } catch (...) {
103536       {
103537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103538       };
103539     }
103540   }
103541   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103542
103543   return jresult;
103544 }
103545
103546
103547 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_4(char * jarg1) {
103548   void * jresult ;
103549   std::string *arg1 = 0 ;
103550   Dali::Devel::PixelBuffer result;
103551
103552   if (!jarg1) {
103553     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103554     return 0;
103555   }
103556   std::string arg1_str(jarg1);
103557   arg1 = &arg1_str;
103558   {
103559     try {
103560       result = Dali::DownloadImageSynchronously((std::string const &)*arg1);
103561     } catch (std::out_of_range& e) {
103562       {
103563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103564       };
103565     } catch (std::exception& e) {
103566       {
103567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103568       };
103569     } catch (...) {
103570       {
103571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103572       };
103573     }
103574   }
103575   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103576
103577   return jresult;
103578 }
103579
103580
103581 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetMaxTextureSize(unsigned int jarg1) {
103582   unsigned int arg1 ;
103583
103584   arg1 = (unsigned int)jarg1;
103585   {
103586     try {
103587       Dali::SetMaxTextureSize(arg1);
103588     } catch (std::out_of_range& e) {
103589       {
103590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103591       };
103592     } catch (std::exception& e) {
103593       {
103594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103595       };
103596     } catch (...) {
103597       {
103598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103599       };
103600     }
103601   }
103602 }
103603
103604
103605 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetMaxTextureSize() {
103606   unsigned int jresult ;
103607   unsigned int result;
103608
103609   {
103610     try {
103611       result = (unsigned int)Dali::GetMaxTextureSize();
103612     } catch (std::out_of_range& e) {
103613       {
103614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103615       };
103616     } catch (std::exception& e) {
103617       {
103618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103619       };
103620     } catch (...) {
103621       {
103622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103623       };
103624     }
103625   }
103626   jresult = result;
103627   return jresult;
103628 }
103629
103630
103631 #ifdef __cplusplus
103632 }
103633 #endif
103634