dali-csharp-binder/src/dali_wrap.cpp

   1 /* ----------------------------------------------------------------------------
   2  * This file was automatically generated by SWIG (http://www.swig.org).
   3  * Version 3.0.9
   4  *
   5  * This file is not intended to be easily readable and contains a number of
   6  * coding conventions designed to improve portability and efficiency. Do not make
   7  * changes to this file unless you know what you are doing--modify the SWIG
   8  * interface file instead.
   9  * ----------------------------------------------------------------------------- */
  10
  11 #ifndef SWIGCSHARP
  12 #define SWIGCSHARP
  13 #endif
  14
  15 #define SWIG_DIRECTORS
  16
  17 #ifdef __cplusplus
  18 /* SwigValueWrapper is described in swig.swg */
  19 template<typename T> class SwigValueWrapper {
  20   struct SwigMovePointer {
  21     T *ptr;
  22     SwigMovePointer(T *p) : ptr(p) { }
  23     ~SwigMovePointer() { delete ptr; }
  24     SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
  25   } pointer;
  26   SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
  27   SwigValueWrapper(const SwigValueWrapper<T>& rhs);
  28 public:
  29   SwigValueWrapper() : pointer(0) { }
  30   SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
  31   operator T&() const { return *pointer.ptr; }
  32   T *operator&() { return pointer.ptr; }
  33 };
  34
  35 template <typename T> T SwigValueInit() {
  36   return T();
  37 }
  38 #endif
  39
  40 /* -----------------------------------------------------------------------------
  41  *  This section contains generic SWIG labels for method/variable
  42  *  declarations/attributes, and other compiler dependent labels.
  43  * ----------------------------------------------------------------------------- */
  44
  45 /* template workaround for compilers that cannot correctly implement the C++ standard */
  46 #ifndef SWIGTEMPLATEDISAMBIGUATOR
  47 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
  48 #  define SWIGTEMPLATEDISAMBIGUATOR template
  49 # elif defined(__HP_aCC)
  50 /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
  51 /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
  52 #  define SWIGTEMPLATEDISAMBIGUATOR template
  53 # else
  54 #  define SWIGTEMPLATEDISAMBIGUATOR
  55 # endif
  56 #endif
  57
  58 /* inline attribute */
  59 #ifndef SWIGINLINE
  60 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
  61 #   define SWIGINLINE inline
  62 # else
  63 #   define SWIGINLINE
  64 # endif
  65 #endif
  66
  67 /* attribute recognised by some compilers to avoid 'unused' warnings */
  68 #ifndef SWIGUNUSED
  69 # if defined(__GNUC__)
  70 #   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
  71 #     define SWIGUNUSED __attribute__ ((__unused__))
  72 #   else
  73 #     define SWIGUNUSED
  74 #   endif
  75 # elif defined(__ICC)
  76 #   define SWIGUNUSED __attribute__ ((__unused__))
  77 # else
  78 #   define SWIGUNUSED
  79 # endif
  80 #endif
  81
  82 #ifndef SWIG_MSC_UNSUPPRESS_4505
  83 # if defined(_MSC_VER)
  84 #   pragma warning(disable : 4505) /* unreferenced local function has been removed */
  85 # endif
  86 #endif
  87
  88 #ifndef SWIGUNUSEDPARM
  89 # ifdef __cplusplus
  90 #   define SWIGUNUSEDPARM(p)
  91 # else
  92 #   define SWIGUNUSEDPARM(p) p SWIGUNUSED
  93 # endif
  94 #endif
  95
  96 /* internal SWIG method */
  97 #ifndef SWIGINTERN
  98 # define SWIGINTERN static SWIGUNUSED
  99 #endif
 100
 101 /* internal inline SWIG method */
 102 #ifndef SWIGINTERNINLINE
 103 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
 104 #endif
 105
 106 /* exporting methods */
 107 #if defined(__GNUC__)
 108 #  if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
 109 #    ifndef GCC_HASCLASSVISIBILITY
 110 #      define GCC_HASCLASSVISIBILITY
 111 #    endif
 112 #  endif
 113 #endif
 114
 115 #ifndef SWIGEXPORT
 116 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
 117 #   if defined(STATIC_LINKED)
 118 #     define SWIGEXPORT
 119 #   else
 120 #     define SWIGEXPORT __declspec(dllexport)
 121 #   endif
 122 # else
 123 #   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
 124 #     define SWIGEXPORT __attribute__ ((visibility("default")))
 125 #   else
 126 #     define SWIGEXPORT
 127 #   endif
 128 # endif
 129 #endif
 130
 131 /* calling conventions for Windows */
 132 #ifndef SWIGSTDCALL
 133 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
 134 #   define SWIGSTDCALL __stdcall
 135 # else
 136 #   define SWIGSTDCALL
 137 # endif
 138 #endif
 139
 140 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
 141 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
 142 # define _CRT_SECURE_NO_DEPRECATE
 143 #endif
 144
 145 /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
 146 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
 147 # define _SCL_SECURE_NO_DEPRECATE
 148 #endif
 149
 150 /* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
 151 #if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
 152 # define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
 153 #endif
 154
 155 /* Intel's compiler complains if a variable which was never initialised is
 156  * cast to void, which is a common idiom which we use to indicate that we
 157  * are aware a variable isn't used.  So we just silence that warning.
 158  * See: https://github.com/swig/swig/issues/192 for more discussion.
 159  */
 160 #ifdef __INTEL_COMPILER
 161 # pragma warning disable 592
 162 #endif
 163
 164
 165 #include <stdlib.h>
 166 #include <string.h>
 167 #include <stdio.h>
 168
 169 /* Support for throwing C# exceptions from C/C++. There are two types:
 170  * Exceptions that take a message and ArgumentExceptions that take a message and a parameter name. */
 171 typedef enum {
 172   SWIG_CSharpApplicationException,
 173   SWIG_CSharpArithmeticException,
 174   SWIG_CSharpDivideByZeroException,
 175   SWIG_CSharpIndexOutOfRangeException,
 176   SWIG_CSharpInvalidCastException,
 177   SWIG_CSharpInvalidOperationException,
 178   SWIG_CSharpIOException,
 179   SWIG_CSharpNullReferenceException,
 180   SWIG_CSharpOutOfMemoryException,
 181   SWIG_CSharpOverflowException,
 182   SWIG_CSharpSystemException
 183 } SWIG_CSharpExceptionCodes;
 184
 185 typedef enum {
 186   SWIG_CSharpArgumentException,
 187   SWIG_CSharpArgumentNullException,
 188   SWIG_CSharpArgumentOutOfRangeException
 189 } SWIG_CSharpExceptionArgumentCodes;
 190
 191 typedef void (SWIGSTDCALL* SWIG_CSharpExceptionCallback_t)(const char *);
 192 typedef void (SWIGSTDCALL* SWIG_CSharpExceptionArgumentCallback_t)(const char *, const char *);
 193
 194 typedef struct {
 195   SWIG_CSharpExceptionCodes code;
 196   SWIG_CSharpExceptionCallback_t callback;
 197 } SWIG_CSharpException_t;
 198
 199 typedef struct {
 200   SWIG_CSharpExceptionArgumentCodes code;
 201   SWIG_CSharpExceptionArgumentCallback_t callback;
 202 } SWIG_CSharpExceptionArgument_t;
 203
 204 SWIG_CSharpException_t SWIG_csharp_exceptions[] = {
 205   { SWIG_CSharpApplicationException, NULL },
 206   { SWIG_CSharpArithmeticException, NULL },
 207   { SWIG_CSharpDivideByZeroException, NULL },
 208   { SWIG_CSharpIndexOutOfRangeException, NULL },
 209   { SWIG_CSharpInvalidCastException, NULL },
 210   { SWIG_CSharpInvalidOperationException, NULL },
 211   { SWIG_CSharpIOException, NULL },
 212   { SWIG_CSharpNullReferenceException, NULL },
 213   { SWIG_CSharpOutOfMemoryException, NULL },
 214   { SWIG_CSharpOverflowException, NULL },
 215   { SWIG_CSharpSystemException, NULL }
 216 };
 217
 218 SWIG_CSharpExceptionArgument_t SWIG_csharp_exceptions_argument[] = {
 219   { SWIG_CSharpArgumentException, NULL },
 220   { SWIG_CSharpArgumentNullException, NULL },
 221   { SWIG_CSharpArgumentOutOfRangeException, NULL }
 222 };
 223
 224 void SWIGUNUSED SWIG_CSharpSetPendingException(SWIG_CSharpExceptionCodes code, const char *msg) {
 225   SWIG_CSharpExceptionCallback_t callback = SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback;
 226   if ((size_t)code < sizeof(SWIG_csharp_exceptions)/sizeof(SWIG_CSharpException_t)) {
 227     callback = SWIG_csharp_exceptions[code].callback;
 228   }
 229   callback(msg);
 230 }
 231
 232 void SWIGUNUSED SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpExceptionArgumentCodes code, const char *msg, const char *param_name) {
 233   SWIG_CSharpExceptionArgumentCallback_t callback = SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback;
 234   if ((size_t)code < sizeof(SWIG_csharp_exceptions_argument)/sizeof(SWIG_CSharpExceptionArgument_t)) {
 235     callback = SWIG_csharp_exceptions_argument[code].callback;
 236   }
 237   callback(msg, param_name);
 238 }
 239
 240
 241 #ifdef __cplusplus
 242 extern "C"
 243 #endif
 244 SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionCallbacks_NDalic(
 245                                                 SWIG_CSharpExceptionCallback_t applicationCallback,
 246                                                 SWIG_CSharpExceptionCallback_t arithmeticCallback,
 247                                                 SWIG_CSharpExceptionCallback_t divideByZeroCallback,
 248                                                 SWIG_CSharpExceptionCallback_t indexOutOfRangeCallback,
 249                                                 SWIG_CSharpExceptionCallback_t invalidCastCallback,
 250                                                 SWIG_CSharpExceptionCallback_t invalidOperationCallback,
 251                                                 SWIG_CSharpExceptionCallback_t ioCallback,
 252                                                 SWIG_CSharpExceptionCallback_t nullReferenceCallback,
 253                                                 SWIG_CSharpExceptionCallback_t outOfMemoryCallback,
 254                                                 SWIG_CSharpExceptionCallback_t overflowCallback,
 255                                                 SWIG_CSharpExceptionCallback_t systemCallback) {
 256   SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback = applicationCallback;
 257   SWIG_csharp_exceptions[SWIG_CSharpArithmeticException].callback = arithmeticCallback;
 258   SWIG_csharp_exceptions[SWIG_CSharpDivideByZeroException].callback = divideByZeroCallback;
 259   SWIG_csharp_exceptions[SWIG_CSharpIndexOutOfRangeException].callback = indexOutOfRangeCallback;
 260   SWIG_csharp_exceptions[SWIG_CSharpInvalidCastException].callback = invalidCastCallback;
 261   SWIG_csharp_exceptions[SWIG_CSharpInvalidOperationException].callback = invalidOperationCallback;
 262   SWIG_csharp_exceptions[SWIG_CSharpIOException].callback = ioCallback;
 263   SWIG_csharp_exceptions[SWIG_CSharpNullReferenceException].callback = nullReferenceCallback;
 264   SWIG_csharp_exceptions[SWIG_CSharpOutOfMemoryException].callback = outOfMemoryCallback;
 265   SWIG_csharp_exceptions[SWIG_CSharpOverflowException].callback = overflowCallback;
 266   SWIG_csharp_exceptions[SWIG_CSharpSystemException].callback = systemCallback;
 267 }
 268
 269 #ifdef __cplusplus
 270 extern "C"
 271 #endif
 272 SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionArgumentCallbacks_NDalic(
 273                                                 SWIG_CSharpExceptionArgumentCallback_t argumentCallback,
 274                                                 SWIG_CSharpExceptionArgumentCallback_t argumentNullCallback,
 275                                                 SWIG_CSharpExceptionArgumentCallback_t argumentOutOfRangeCallback) {
 276   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback = argumentCallback;
 277   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentNullException].callback = argumentNullCallback;
 278   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentOutOfRangeException].callback = argumentOutOfRangeCallback;
 279 }
 280
 281
 282 /* Callback for returning strings to C# without leaking memory */
 283 typedef char * (SWIGSTDCALL* SWIG_CSharpStringHelperCallback)(const char *);
 284 SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback = NULL;
 285
 286 // keep argWidgetCs and argWidgetV so they're always available to DALi
 287 int argWidgetC = 1;
 288 char **argWidgetV = NULL;
 289
 290 #ifdef __cplusplus
 291 extern "C"
 292 #endif
 293 SWIGEXPORT void SWIGSTDCALL SWIGRegisterStringCallback_NDalic(SWIG_CSharpStringHelperCallback callback) {
 294   SWIG_csharp_string_callback = callback;
 295 }
 296
 297
 298 /* Contract support */
 299
 300 #define SWIG_contract_assert(nullreturn, expr, msg) if (!(expr)) {SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, msg, ""); return nullreturn; } else
 301
 302 /*  Errors in SWIG */
 303 #define  SWIG_UnknownError         -1
 304 #define  SWIG_IOError              -2
 305 #define  SWIG_RuntimeError         -3
 306 #define  SWIG_IndexError           -4
 307 #define  SWIG_TypeError            -5
 308 #define  SWIG_DivisionByZero       -6
 309 #define  SWIG_OverflowError        -7
 310 #define  SWIG_SyntaxError          -8
 311 #define  SWIG_ValueError           -9
 312 #define  SWIG_SystemError          -10
 313 #define  SWIG_AttributeError       -11
 314 #define  SWIG_MemoryError          -12
 315 #define  SWIG_NullReferenceError   -13
 316
 317
 318
 319 /* -----------------------------------------------------------------------------
 320  * director_common.swg
 321  *
 322  * This file contains support for director classes which is common between
 323  * languages.
 324  * ----------------------------------------------------------------------------- */
 325
 326 /*
 327   Use -DSWIG_DIRECTOR_STATIC if you prefer to avoid the use of the
 328   'Swig' namespace. This could be useful for multi-modules projects.
 329 */
 330 #ifdef SWIG_DIRECTOR_STATIC
 331 /* Force anonymous (static) namespace */
 332 #define Swig
 333 #endif
 334 /* -----------------------------------------------------------------------------
 335  * director.swg
 336  *
 337  * This file contains support for director classes so that C# proxy
 338  * methods can be called from C++.
 339  * ----------------------------------------------------------------------------- */
 340
 341 #if defined(DEBUG_DIRECTOR_OWNED)
 342 #include <iostream>
 343 #endif
 344 #include <string>
 345 #include <exception>
 346
 347 namespace Swig {
 348   /* Director base class - not currently used in C# directors */
 349   class Director {
 350   };
 351
 352   /* Base class for director exceptions */
 353   class DirectorException : public std::exception {
 354   protected:
 355     std::string swig_msg;
 356
 357   public:
 358     DirectorException(const char *msg) : swig_msg(msg) {
 359     }
 360
 361     DirectorException(const std::string &msg) : swig_msg(msg) {
 362     }
 363
 364     virtual ~DirectorException() throw() {
 365     }
 366
 367     const char *what() const throw() {
 368       return swig_msg.c_str();
 369     }
 370   };
 371
 372   /* Pure virtual method exception */
 373   class DirectorPureVirtualException : public DirectorException {
 374   public:
 375     DirectorPureVirtualException(const char *msg) : DirectorException(std::string("Attempt to invoke pure virtual method ") + msg) {
 376     }
 377   };
 378 }
 379
 380
 381 void SWIG_CSharpException(int code, const char *msg) {
 382   if (code == SWIG_ValueError) {
 383     SWIG_CSharpExceptionArgumentCodes exception_code = SWIG_CSharpArgumentOutOfRangeException;
 384     SWIG_CSharpSetPendingExceptionArgument(exception_code, msg, 0);
 385   } else {
 386     SWIG_CSharpExceptionCodes exception_code = SWIG_CSharpApplicationException;
 387     switch(code) {
 388     case SWIG_MemoryError:
 389       exception_code = SWIG_CSharpOutOfMemoryException;
 390       break;
 391     case SWIG_IndexError:
 392       exception_code = SWIG_CSharpIndexOutOfRangeException;
 393       break;
 394     case SWIG_DivisionByZero:
 395       exception_code = SWIG_CSharpDivideByZeroException;
 396       break;
 397     case SWIG_IOError:
 398       exception_code = SWIG_CSharpIOException;
 399       break;
 400     case SWIG_OverflowError:
 401       exception_code = SWIG_CSharpOverflowException;
 402       break;
 403     case SWIG_RuntimeError:
 404     case SWIG_TypeError:
 405     case SWIG_SyntaxError:
 406     case SWIG_SystemError:
 407     case SWIG_UnknownError:
 408     default:
 409       exception_code = SWIG_CSharpApplicationException;
 410       break;
 411     }
 412     SWIG_CSharpSetPendingException(exception_code, msg);
 413   }
 414 }
 415
 416
 417 #include <stdexcept>
 418
 419
 420 #define SWIGSTDCALL
 421
 422
 423 #include <dali/dali.h>
 424 #include <dali-toolkit/dali-toolkit.h>
 425
 426 #include <dali/devel-api/actors/actor-devel.h>
 427
 428 #include <dali/public-api/math/matrix.h>
 429 #include <dali/public-api/math/matrix3.h>
 430 #include <dali/public-api/math/viewport.h>
 431 #include <dali/public-api/object/property-key.h>
 432 #include <dali/devel-api/object/csharp-type-info.h>
 433 #include <dali/devel-api/object/csharp-type-registry.h>
 434
 435 #include <dali/public-api/adaptor-framework/timer.h>
 436 #include <dali/public-api/adaptor-framework/style-change.h>
 437 #include <dali/devel-api/adaptor-framework/drag-and-drop-detector.h>
 438 #include <dali/devel-api/adaptor-framework/application-extensions.h>
 439
 440 #include <dali/devel-api/images/nine-patch-image.h>
 441
 442 #include <dali-toolkit/devel-api/builder/builder.h>
 443
 444 #include <dali-toolkit/devel-api/focus-manager/keyinput-focus-manager.h>
 445 #include <dali-toolkit/devel-api/focus-manager/keyboard-focus-manager-devel.h>
 446
 447 #include <dali-toolkit/devel-api/controls/control-devel.h>
 448 #include <dali-toolkit/devel-api/controls/popup/popup.h>
 449 #include <dali-toolkit/devel-api/controls/gaussian-blur-view/gaussian-blur-view.h>
 450 #include <dali-toolkit/devel-api/controls/page-turn-view/page-factory.h>
 451 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-view.h>
 452 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-landscape-view.h>
 453 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-portrait-view.h>
 454 #include <dali-toolkit/devel-api/controls/buttons/toggle-button.h>
 455
 456 #include <dali-toolkit/devel-api/visual-factory/visual-base.h>
 457 #include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
 458 #include <dali-toolkit/devel-api/visual-factory/transition-data.h>
 459
 460 #include <dali-toolkit/public-api/visuals/visual-properties.h>
 461 #include <dali-toolkit/public-api/visuals/text-visual-properties.h>
 462 #include <dali-toolkit/public-api/visuals/image-visual-properties.h>
 463
 464 #include <dali-toolkit/devel-api/controls/tooltip/tooltip-properties.h>
 465 #include <dali-toolkit/devel-api/visuals/image-visual-properties-devel.h>
 466
 467 #include <dali-toolkit/public-api/controls/scrollable/item-view/item-view-declarations.h>
 468
 469 #include <dali/devel-api/adaptor-framework/pixel-buffer.h>
 470 #include <dali/devel-api/adaptor-framework/image-loading.h>
 471
 472 #include <dali/public-api/events/mouse-button.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 int SWIGSTDCALL CSharp_Dali_Touch_GetMouseButton(void * jarg1, unsigned long jarg2) {
30274   int jresult ;
30275   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30276   std::size_t arg2 ;
30277   Dali::MouseButton::Type result;
30278
30279   arg1 = (Dali::TouchData *)jarg1;
30280   arg2 = (std::size_t)jarg2;
30281   {
30282     try {
30283       result = ((Dali::TouchData const *)arg1)->GetMouseButton(arg2);
30284     } catch (std::out_of_range& e) {
30285       {
30286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30287       };
30288     } catch (std::exception& e) {
30289       {
30290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30291       };
30292     } catch (Dali::DaliException e) {
30293       {
30294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30295       };
30296     } catch (...) {
30297       {
30298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30299       };
30300     }
30301   }
30302
30303   jresult = static_cast< int >(result);
30304   return jresult;
30305 }
30306
30307
30308 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_0() {
30309   void * jresult ;
30310   Dali::GestureDetector *result = 0 ;
30311
30312   {
30313     try {
30314       result = (Dali::GestureDetector *)new Dali::GestureDetector();
30315     } catch (std::out_of_range& e) {
30316       {
30317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30318       };
30319     } catch (std::exception& e) {
30320       {
30321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30322       };
30323     } catch (Dali::DaliException e) {
30324       {
30325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30326       };
30327     } catch (...) {
30328       {
30329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30330       };
30331     }
30332   }
30333
30334   jresult = (void *)result;
30335   return jresult;
30336 }
30337
30338
30339 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_DownCast(void * jarg1) {
30340   void * jresult ;
30341   Dali::BaseHandle arg1 ;
30342   Dali::BaseHandle *argp1 ;
30343   Dali::GestureDetector result;
30344
30345   argp1 = (Dali::BaseHandle *)jarg1;
30346   if (!argp1) {
30347     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
30348     return 0;
30349   }
30350   arg1 = *argp1;
30351   {
30352     try {
30353       result = Dali::GestureDetector::DownCast(arg1);
30354     } catch (std::out_of_range& e) {
30355       {
30356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30357       };
30358     } catch (std::exception& e) {
30359       {
30360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30361       };
30362     } catch (Dali::DaliException e) {
30363       {
30364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30365       };
30366     } catch (...) {
30367       {
30368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30369       };
30370     }
30371   }
30372
30373   jresult = new Dali::GestureDetector((const Dali::GestureDetector &)result);
30374   return jresult;
30375 }
30376
30377
30378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GestureDetector(void * jarg1) {
30379   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30380
30381   arg1 = (Dali::GestureDetector *)jarg1;
30382   {
30383     try {
30384       delete arg1;
30385     } catch (std::out_of_range& e) {
30386       {
30387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30388       };
30389     } catch (std::exception& e) {
30390       {
30391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30392       };
30393     } catch (Dali::DaliException e) {
30394       {
30395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30396       };
30397     } catch (...) {
30398       {
30399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30400       };
30401     }
30402   }
30403
30404 }
30405
30406
30407 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_1(void * jarg1) {
30408   void * jresult ;
30409   Dali::GestureDetector *arg1 = 0 ;
30410   Dali::GestureDetector *result = 0 ;
30411
30412   arg1 = (Dali::GestureDetector *)jarg1;
30413   if (!arg1) {
30414     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
30415     return 0;
30416   }
30417   {
30418     try {
30419       result = (Dali::GestureDetector *)new Dali::GestureDetector((Dali::GestureDetector const &)*arg1);
30420     } catch (std::out_of_range& e) {
30421       {
30422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30423       };
30424     } catch (std::exception& e) {
30425       {
30426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30427       };
30428     } catch (Dali::DaliException e) {
30429       {
30430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30431       };
30432     } catch (...) {
30433       {
30434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30435       };
30436     }
30437   }
30438
30439   jresult = (void *)result;
30440   return jresult;
30441 }
30442
30443
30444 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_Assign(void * jarg1, void * jarg2) {
30445   void * jresult ;
30446   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30447   Dali::GestureDetector *arg2 = 0 ;
30448   Dali::GestureDetector *result = 0 ;
30449
30450   arg1 = (Dali::GestureDetector *)jarg1;
30451   arg2 = (Dali::GestureDetector *)jarg2;
30452   if (!arg2) {
30453     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
30454     return 0;
30455   }
30456   {
30457     try {
30458       result = (Dali::GestureDetector *) &(arg1)->operator =((Dali::GestureDetector const &)*arg2);
30459     } catch (std::out_of_range& e) {
30460       {
30461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30462       };
30463     } catch (std::exception& e) {
30464       {
30465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30466       };
30467     } catch (Dali::DaliException e) {
30468       {
30469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30470       };
30471     } catch (...) {
30472       {
30473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30474       };
30475     }
30476   }
30477
30478   jresult = (void *)result;
30479   return jresult;
30480 }
30481
30482
30483 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Attach(void * jarg1, void * jarg2) {
30484   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30485   Dali::Actor arg2 ;
30486   Dali::Actor *argp2 ;
30487
30488   arg1 = (Dali::GestureDetector *)jarg1;
30489   argp2 = (Dali::Actor *)jarg2;
30490   if (!argp2) {
30491     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
30492     return ;
30493   }
30494   arg2 = *argp2;
30495   {
30496     try {
30497       (arg1)->Attach(arg2);
30498     } catch (std::out_of_range& e) {
30499       {
30500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30501       };
30502     } catch (std::exception& e) {
30503       {
30504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30505       };
30506     } catch (Dali::DaliException e) {
30507       {
30508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30509       };
30510     } catch (...) {
30511       {
30512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30513       };
30514     }
30515   }
30516
30517 }
30518
30519
30520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Detach(void * jarg1, void * jarg2) {
30521   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30522   Dali::Actor arg2 ;
30523   Dali::Actor *argp2 ;
30524
30525   arg1 = (Dali::GestureDetector *)jarg1;
30526   argp2 = (Dali::Actor *)jarg2;
30527   if (!argp2) {
30528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
30529     return ;
30530   }
30531   arg2 = *argp2;
30532   {
30533     try {
30534       (arg1)->Detach(arg2);
30535     } catch (std::out_of_range& e) {
30536       {
30537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30538       };
30539     } catch (std::exception& e) {
30540       {
30541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30542       };
30543     } catch (Dali::DaliException e) {
30544       {
30545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30546       };
30547     } catch (...) {
30548       {
30549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30550       };
30551     }
30552   }
30553
30554 }
30555
30556
30557 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_DetachAll(void * jarg1) {
30558   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30559
30560   arg1 = (Dali::GestureDetector *)jarg1;
30561   {
30562     try {
30563       (arg1)->DetachAll();
30564     } catch (std::out_of_range& e) {
30565       {
30566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30567       };
30568     } catch (std::exception& e) {
30569       {
30570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30571       };
30572     } catch (Dali::DaliException e) {
30573       {
30574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30575       };
30576     } catch (...) {
30577       {
30578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30579       };
30580     }
30581   }
30582
30583 }
30584
30585
30586 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActorCount(void * jarg1) {
30587   unsigned long jresult ;
30588   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30589   size_t result;
30590
30591   arg1 = (Dali::GestureDetector *)jarg1;
30592   {
30593     try {
30594       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActorCount();
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 = (unsigned long)result;
30615   return jresult;
30616 }
30617
30618
30619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActor(void * jarg1, unsigned long jarg2) {
30620   void * jresult ;
30621   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30622   size_t arg2 ;
30623   Dali::Actor result;
30624
30625   arg1 = (Dali::GestureDetector *)jarg1;
30626   arg2 = (size_t)jarg2;
30627   {
30628     try {
30629       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActor(arg2);
30630     } catch (std::out_of_range& e) {
30631       {
30632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30633       };
30634     } catch (std::exception& e) {
30635       {
30636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30637       };
30638     } catch (Dali::DaliException e) {
30639       {
30640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30641       };
30642     } catch (...) {
30643       {
30644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30645       };
30646     }
30647   }
30648
30649   jresult = new Dali::Actor((const Dali::Actor &)result);
30650   return jresult;
30651 }
30652
30653
30654 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Gesture(void * jarg1) {
30655   void * jresult ;
30656   Dali::Gesture *arg1 = 0 ;
30657   Dali::Gesture *result = 0 ;
30658
30659   arg1 = (Dali::Gesture *)jarg1;
30660   if (!arg1) {
30661     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
30662     return 0;
30663   }
30664   {
30665     try {
30666       result = (Dali::Gesture *)new Dali::Gesture((Dali::Gesture const &)*arg1);
30667     } catch (std::out_of_range& e) {
30668       {
30669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30670       };
30671     } catch (std::exception& e) {
30672       {
30673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30674       };
30675     } catch (Dali::DaliException e) {
30676       {
30677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30678       };
30679     } catch (...) {
30680       {
30681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30682       };
30683     }
30684   }
30685
30686   jresult = (void *)result;
30687   return jresult;
30688 }
30689
30690
30691 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Gesture_Assign(void * jarg1, void * jarg2) {
30692   void * jresult ;
30693   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30694   Dali::Gesture *arg2 = 0 ;
30695   Dali::Gesture *result = 0 ;
30696
30697   arg1 = (Dali::Gesture *)jarg1;
30698   arg2 = (Dali::Gesture *)jarg2;
30699   if (!arg2) {
30700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
30701     return 0;
30702   }
30703   {
30704     try {
30705       result = (Dali::Gesture *) &(arg1)->operator =((Dali::Gesture const &)*arg2);
30706     } catch (std::out_of_range& e) {
30707       {
30708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30709       };
30710     } catch (std::exception& e) {
30711       {
30712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30713       };
30714     } catch (Dali::DaliException e) {
30715       {
30716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30717       };
30718     } catch (...) {
30719       {
30720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30721       };
30722     }
30723   }
30724
30725   jresult = (void *)result;
30726   return jresult;
30727 }
30728
30729
30730 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Gesture(void * jarg1) {
30731   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30732
30733   arg1 = (Dali::Gesture *)jarg1;
30734   {
30735     try {
30736       delete arg1;
30737     } catch (std::out_of_range& e) {
30738       {
30739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30740       };
30741     } catch (std::exception& e) {
30742       {
30743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30744       };
30745     } catch (Dali::DaliException e) {
30746       {
30747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30748       };
30749     } catch (...) {
30750       {
30751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30752       };
30753     }
30754   }
30755
30756 }
30757
30758
30759 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_type_set(void * jarg1, int jarg2) {
30760   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30761   Dali::Gesture::Type arg2 ;
30762
30763   arg1 = (Dali::Gesture *)jarg1;
30764   arg2 = (Dali::Gesture::Type)jarg2;
30765   if (arg1) (arg1)->type = arg2;
30766 }
30767
30768
30769 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_type_get(void * jarg1) {
30770   int jresult ;
30771   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30772   Dali::Gesture::Type result;
30773
30774   arg1 = (Dali::Gesture *)jarg1;
30775   result = (Dali::Gesture::Type) ((arg1)->type);
30776   jresult = (int)result;
30777   return jresult;
30778 }
30779
30780
30781 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_state_set(void * jarg1, int jarg2) {
30782   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30783   Dali::Gesture::State arg2 ;
30784
30785   arg1 = (Dali::Gesture *)jarg1;
30786   arg2 = (Dali::Gesture::State)jarg2;
30787   if (arg1) (arg1)->state = arg2;
30788 }
30789
30790
30791 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_state_get(void * jarg1) {
30792   int jresult ;
30793   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30794   Dali::Gesture::State result;
30795
30796   arg1 = (Dali::Gesture *)jarg1;
30797   result = (Dali::Gesture::State) ((arg1)->state);
30798   jresult = (int)result;
30799   return jresult;
30800 }
30801
30802
30803 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_time_set(void * jarg1, unsigned int jarg2) {
30804   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30805   unsigned int arg2 ;
30806
30807   arg1 = (Dali::Gesture *)jarg1;
30808   arg2 = (unsigned int)jarg2;
30809   if (arg1) (arg1)->time = arg2;
30810 }
30811
30812
30813 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Gesture_time_get(void * jarg1) {
30814   unsigned int jresult ;
30815   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30816   unsigned int result;
30817
30818   arg1 = (Dali::Gesture *)jarg1;
30819   result = (unsigned int) ((arg1)->time);
30820   jresult = result;
30821   return jresult;
30822 }
30823
30824
30825 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_0() {
30826   void * jresult ;
30827   Dali::HoverEvent *result = 0 ;
30828
30829   {
30830     try {
30831       result = (Dali::HoverEvent *)new Dali::HoverEvent();
30832     } catch (std::out_of_range& e) {
30833       {
30834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30835       };
30836     } catch (std::exception& e) {
30837       {
30838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30839       };
30840     } catch (Dali::DaliException e) {
30841       {
30842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30843       };
30844     } catch (...) {
30845       {
30846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30847       };
30848     }
30849   }
30850
30851   jresult = (void *)result;
30852   return jresult;
30853 }
30854
30855
30856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_1(unsigned long jarg1) {
30857   void * jresult ;
30858   unsigned long arg1 ;
30859   Dali::HoverEvent *result = 0 ;
30860
30861   arg1 = (unsigned long)jarg1;
30862   {
30863     try {
30864       result = (Dali::HoverEvent *)new Dali::HoverEvent(arg1);
30865     } catch (std::out_of_range& e) {
30866       {
30867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30868       };
30869     } catch (std::exception& e) {
30870       {
30871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30872       };
30873     } catch (Dali::DaliException e) {
30874       {
30875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30876       };
30877     } catch (...) {
30878       {
30879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30880       };
30881     }
30882   }
30883
30884   jresult = (void *)result;
30885   return jresult;
30886 }
30887
30888
30889 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Hover(void * jarg1) {
30890   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30891
30892   arg1 = (Dali::HoverEvent *)jarg1;
30893   {
30894     try {
30895       delete arg1;
30896     } catch (std::out_of_range& e) {
30897       {
30898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30899       };
30900     } catch (std::exception& e) {
30901       {
30902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30903       };
30904     } catch (Dali::DaliException e) {
30905       {
30906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30907       };
30908     } catch (...) {
30909       {
30910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30911       };
30912     }
30913   }
30914
30915 }
30916
30917
30918 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_points_set(void * jarg1, void * jarg2) {
30919   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30920   Dali::TouchPointContainer *arg2 = (Dali::TouchPointContainer *) 0 ;
30921
30922   arg1 = (Dali::HoverEvent *)jarg1;
30923   arg2 = (Dali::TouchPointContainer *)jarg2;
30924   if (arg1) (arg1)->points = *arg2;
30925 }
30926
30927
30928 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_points_get(void * jarg1) {
30929   void * jresult ;
30930   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30931   Dali::TouchPointContainer *result = 0 ;
30932
30933   arg1 = (Dali::HoverEvent *)jarg1;
30934   result = (Dali::TouchPointContainer *)& ((arg1)->points);
30935   jresult = (void *)result;
30936   return jresult;
30937 }
30938
30939
30940 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_time_set(void * jarg1, unsigned long jarg2) {
30941   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30942   unsigned long arg2 ;
30943
30944   arg1 = (Dali::HoverEvent *)jarg1;
30945   arg2 = (unsigned long)jarg2;
30946   if (arg1) (arg1)->time = arg2;
30947 }
30948
30949
30950 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Hover_time_get(void * jarg1) {
30951   unsigned long jresult ;
30952   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30953   unsigned long result;
30954
30955   arg1 = (Dali::HoverEvent *)jarg1;
30956   result = (unsigned long) ((arg1)->time);
30957   jresult = (unsigned long)result;
30958   return jresult;
30959 }
30960
30961
30962 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Hover_GetPointCount(void * jarg1) {
30963   unsigned int jresult ;
30964   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30965   unsigned int result;
30966
30967   arg1 = (Dali::HoverEvent *)jarg1;
30968   {
30969     try {
30970       result = (unsigned int)((Dali::HoverEvent const *)arg1)->GetPointCount();
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 = result;
30991   return jresult;
30992 }
30993
30994
30995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetPoint(void * jarg1, unsigned int jarg2) {
30996   void * jresult ;
30997   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30998   unsigned int arg2 ;
30999   Dali::TouchPoint *result = 0 ;
31000
31001   arg1 = (Dali::HoverEvent *)jarg1;
31002   arg2 = (unsigned int)jarg2;
31003   {
31004     try {
31005       result = (Dali::TouchPoint *) &((Dali::HoverEvent const *)arg1)->GetPoint(arg2);
31006     } catch (std::out_of_range& e) {
31007       {
31008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31009       };
31010     } catch (std::exception& e) {
31011       {
31012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31013       };
31014     } catch (Dali::DaliException e) {
31015       {
31016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31017       };
31018     } catch (...) {
31019       {
31020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31021       };
31022     }
31023   }
31024
31025   jresult = (void *)result;
31026   return jresult;
31027 }
31028
31029
31030 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_0() {
31031   void * jresult ;
31032   Dali::KeyEvent *result = 0 ;
31033
31034   {
31035     try {
31036       result = (Dali::KeyEvent *)new Dali::KeyEvent();
31037     } catch (std::out_of_range& e) {
31038       {
31039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31040       };
31041     } catch (std::exception& e) {
31042       {
31043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31044       };
31045     } catch (Dali::DaliException e) {
31046       {
31047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31048       };
31049     } catch (...) {
31050       {
31051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31052       };
31053     }
31054   }
31055
31056   jresult = (void *)result;
31057   return jresult;
31058 }
31059
31060
31061 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_1(char * jarg1, char * jarg2, int jarg3, int jarg4, unsigned long jarg5, int jarg6) {
31062   void * jresult ;
31063   std::string *arg1 = 0 ;
31064   std::string *arg2 = 0 ;
31065   int arg3 ;
31066   int arg4 ;
31067   unsigned long arg5 ;
31068   Dali::KeyEvent::State *arg6 = 0 ;
31069   Dali::KeyEvent::State temp6 ;
31070   Dali::KeyEvent *result = 0 ;
31071
31072   if (!jarg1) {
31073     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31074     return 0;
31075   }
31076   std::string arg1_str(jarg1);
31077   arg1 = &arg1_str;
31078   if (!jarg2) {
31079     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31080     return 0;
31081   }
31082   std::string arg2_str(jarg2);
31083   arg2 = &arg2_str;
31084   arg3 = (int)jarg3;
31085   arg4 = (int)jarg4;
31086   arg5 = (unsigned long)jarg5;
31087   temp6 = (Dali::KeyEvent::State)jarg6;
31088   arg6 = &temp6;
31089   {
31090     try {
31091       result = (Dali::KeyEvent *)new Dali::KeyEvent((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,(Dali::KeyEvent::State const &)*arg6);
31092     } catch (std::out_of_range& e) {
31093       {
31094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31095       };
31096     } catch (std::exception& e) {
31097       {
31098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31099       };
31100     } catch (Dali::DaliException e) {
31101       {
31102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31103       };
31104     } catch (...) {
31105       {
31106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31107       };
31108     }
31109   }
31110
31111   jresult = (void *)result;
31112
31113   //argout typemap for const std::string&
31114
31115
31116   //argout typemap for const std::string&
31117
31118   return jresult;
31119 }
31120
31121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_2(void * jarg1) {
31122   void * jresult ;
31123   Dali::KeyEvent *arg1 = 0 ;
31124   Dali::KeyEvent *result = 0 ;
31125
31126   arg1 = (Dali::KeyEvent *)jarg1;
31127   if (!arg1) {
31128     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
31129     return 0;
31130   }
31131   {
31132     try {
31133       result = (Dali::KeyEvent *)new Dali::KeyEvent((Dali::KeyEvent const &)*arg1);
31134     } catch (std::out_of_range& e) {
31135       {
31136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31137       };
31138     } catch (std::exception& e) {
31139       {
31140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31141       };
31142     } catch (Dali::DaliException e) {
31143       {
31144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31145       };
31146     } catch (...) {
31147       {
31148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31149       };
31150     }
31151   }
31152
31153   jresult = (void *)result;
31154   return jresult;
31155 }
31156
31157
31158 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Key_Assign(void * jarg1, void * jarg2) {
31159   void * jresult ;
31160   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31161   Dali::KeyEvent *arg2 = 0 ;
31162   Dali::KeyEvent *result = 0 ;
31163
31164   arg1 = (Dali::KeyEvent *)jarg1;
31165   arg2 = (Dali::KeyEvent *)jarg2;
31166   if (!arg2) {
31167     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
31168     return 0;
31169   }
31170   {
31171     try {
31172       result = (Dali::KeyEvent *) &(arg1)->operator =((Dali::KeyEvent const &)*arg2);
31173     } catch (std::out_of_range& e) {
31174       {
31175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31176       };
31177     } catch (std::exception& e) {
31178       {
31179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31180       };
31181     } catch (Dali::DaliException e) {
31182       {
31183         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31184       };
31185     } catch (...) {
31186       {
31187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31188       };
31189     }
31190   }
31191
31192   jresult = (void *)result;
31193   return jresult;
31194 }
31195
31196
31197 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Key(void * jarg1) {
31198   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31199
31200   arg1 = (Dali::KeyEvent *)jarg1;
31201   {
31202     try {
31203       delete arg1;
31204     } catch (std::out_of_range& e) {
31205       {
31206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31207       };
31208     } catch (std::exception& e) {
31209       {
31210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31211       };
31212     } catch (Dali::DaliException e) {
31213       {
31214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31215       };
31216     } catch (...) {
31217       {
31218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31219       };
31220     }
31221   }
31222
31223 }
31224
31225
31226 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsShiftModifier(void * jarg1) {
31227   unsigned int jresult ;
31228   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31229   bool result;
31230
31231   arg1 = (Dali::KeyEvent *)jarg1;
31232   {
31233     try {
31234       result = (bool)((Dali::KeyEvent const *)arg1)->IsShiftModifier();
31235     } catch (std::out_of_range& e) {
31236       {
31237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31238       };
31239     } catch (std::exception& e) {
31240       {
31241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31242       };
31243     } catch (Dali::DaliException e) {
31244       {
31245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31246       };
31247     } catch (...) {
31248       {
31249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31250       };
31251     }
31252   }
31253
31254   jresult = result;
31255   return jresult;
31256 }
31257
31258
31259 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsCtrlModifier(void * jarg1) {
31260   unsigned int jresult ;
31261   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31262   bool result;
31263
31264   arg1 = (Dali::KeyEvent *)jarg1;
31265   {
31266     try {
31267       result = (bool)((Dali::KeyEvent const *)arg1)->IsCtrlModifier();
31268     } catch (std::out_of_range& e) {
31269       {
31270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31271       };
31272     } catch (std::exception& e) {
31273       {
31274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31275       };
31276     } catch (Dali::DaliException e) {
31277       {
31278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31279       };
31280     } catch (...) {
31281       {
31282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31283       };
31284     }
31285   }
31286
31287   jresult = result;
31288   return jresult;
31289 }
31290
31291
31292 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsAltModifier(void * jarg1) {
31293   unsigned int jresult ;
31294   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31295   bool result;
31296
31297   arg1 = (Dali::KeyEvent *)jarg1;
31298   {
31299     try {
31300       result = (bool)((Dali::KeyEvent const *)arg1)->IsAltModifier();
31301     } catch (std::out_of_range& e) {
31302       {
31303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31304       };
31305     } catch (std::exception& e) {
31306       {
31307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31308       };
31309     } catch (Dali::DaliException e) {
31310       {
31311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31312       };
31313     } catch (...) {
31314       {
31315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31316       };
31317     }
31318   }
31319
31320   jresult = result;
31321   return jresult;
31322 }
31323
31324
31325 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressedName_set(void * jarg1, char * jarg2) {
31326   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31327   std::string *arg2 = 0 ;
31328
31329   arg1 = (Dali::KeyEvent *)jarg1;
31330   if (!jarg2) {
31331     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31332     return ;
31333   }
31334   std::string arg2_str(jarg2);
31335   arg2 = &arg2_str;
31336   if (arg1) (arg1)->keyPressedName = *arg2;
31337
31338   //argout typemap for const std::string&
31339
31340 }
31341
31342
31343 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressedName_get(void * jarg1) {
31344   char * jresult ;
31345
31346   if( jarg1 == NULL )
31347   {
31348     jresult = SWIG_csharp_string_callback( "" );
31349   }
31350   else
31351   {
31352     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31353     std::string *result = 0;
31354
31355     arg1 = ( Dali::KeyEvent * )jarg1;
31356     result = ( std::string * ) & ( ( arg1 )->keyPressedName );
31357     jresult = SWIG_csharp_string_callback( result->c_str() );
31358   }
31359
31360   return jresult;
31361 }
31362
31363
31364 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressed_set(void * jarg1, char * jarg2) {
31365   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31366   std::string *arg2 = 0 ;
31367
31368   arg1 = (Dali::KeyEvent *)jarg1;
31369   if (!jarg2) {
31370     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31371     return ;
31372   }
31373   std::string arg2_str(jarg2);
31374   arg2 = &arg2_str;
31375   if (arg1) (arg1)->keyPressed = *arg2;
31376
31377   //argout typemap for const std::string&
31378
31379 }
31380
31381
31382 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressed_get(void * jarg1) {
31383   char * jresult ;
31384   if( NULL == jarg1 )
31385   {
31386     jresult = SWIG_csharp_string_callback( "" );
31387   }
31388   else
31389   {
31390     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31391     std::string *result = 0;
31392
31393     arg1 = ( Dali::KeyEvent * )jarg1;
31394     result = ( std::string * ) & ( ( arg1 )->keyPressed );
31395     jresult = SWIG_csharp_string_callback( result->c_str() );
31396   }
31397   return jresult;
31398 }
31399
31400
31401 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyCode_set(void * jarg1, int jarg2) {
31402   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31403   int arg2 ;
31404
31405   arg1 = (Dali::KeyEvent *)jarg1;
31406   arg2 = (int)jarg2;
31407   if (arg1) (arg1)->keyCode = arg2;
31408 }
31409
31410
31411 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyCode_get(void * jarg1) {
31412   int jresult ;
31413   if( NULL == jarg1 )
31414   {
31415     jresult = -1;
31416   }
31417   else
31418   {
31419     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31420     int result;
31421
31422     arg1 = ( Dali::KeyEvent * )jarg1;
31423     result = (int)( ( arg1 )->keyCode );
31424     jresult = result;
31425   }
31426   return jresult;
31427 }
31428
31429
31430 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyModifier_set(void * jarg1, int jarg2) {
31431   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31432   int arg2 ;
31433
31434   arg1 = (Dali::KeyEvent *)jarg1;
31435   arg2 = (int)jarg2;
31436   if (arg1) (arg1)->keyModifier = arg2;
31437 }
31438
31439
31440 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyModifier_get(void * jarg1) {
31441   int jresult ;
31442   if( jarg1 == NULL )
31443   {
31444     jresult = -1;
31445   }
31446   else
31447   {
31448     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31449     int result;
31450
31451     arg1 = ( Dali::KeyEvent * )jarg1;
31452     result = (int)( ( arg1 )->keyModifier );
31453     jresult = result;
31454   }
31455   return jresult;
31456 }
31457
31458
31459 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_time_set(void * jarg1, unsigned long jarg2) {
31460   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31461   unsigned long arg2 ;
31462
31463   arg1 = (Dali::KeyEvent *)jarg1;
31464   arg2 = (unsigned long)jarg2;
31465   if (arg1) (arg1)->time = arg2;
31466 }
31467
31468
31469 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Key_time_get(void * jarg1) {
31470   unsigned long jresult ;
31471   if( jarg1 == NULL )
31472   {
31473     jresult = 0;
31474   }
31475   else
31476   {
31477     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31478     unsigned long result;
31479
31480     arg1 = ( Dali::KeyEvent * )jarg1;
31481     result = (unsigned long)( ( arg1 )->time );
31482     jresult = (unsigned long)result;
31483   }
31484   return jresult;
31485 }
31486
31487
31488 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_state_set(void * jarg1, int jarg2) {
31489   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31490   Dali::KeyEvent::State arg2 ;
31491
31492   arg1 = (Dali::KeyEvent *)jarg1;
31493   arg2 = (Dali::KeyEvent::State)jarg2;
31494   if (arg1) (arg1)->state = arg2;
31495 }
31496
31497
31498 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_state_get(void * jarg1) {
31499   int jresult ;
31500   if( jarg1 == NULL )
31501   {
31502     jresult = -1;
31503   }
31504   else
31505   {
31506     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31507     Dali::KeyEvent::State result;
31508
31509     arg1 = ( Dali::KeyEvent * )jarg1;
31510     result = ( Dali::KeyEvent::State ) ( ( arg1 )->state );
31511     jresult = (int)result;
31512   }
31513   return jresult;
31514 }
31515
31516
31517 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_0() {
31518   void * jresult ;
31519   Dali::LongPressGestureDetector *result = 0 ;
31520
31521   {
31522     try {
31523       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector();
31524     } catch (std::out_of_range& e) {
31525       {
31526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31527       };
31528     } catch (std::exception& e) {
31529       {
31530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31531       };
31532     } catch (Dali::DaliException e) {
31533       {
31534         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31535       };
31536     } catch (...) {
31537       {
31538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31539       };
31540     }
31541   }
31542
31543   jresult = (void *)result;
31544   return jresult;
31545 }
31546
31547
31548 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_0() {
31549   void * jresult ;
31550   Dali::LongPressGestureDetector result;
31551
31552   {
31553     try {
31554       result = Dali::LongPressGestureDetector::New();
31555     } catch (std::out_of_range& e) {
31556       {
31557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31558       };
31559     } catch (std::exception& e) {
31560       {
31561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31562       };
31563     } catch (Dali::DaliException e) {
31564       {
31565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31566       };
31567     } catch (...) {
31568       {
31569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31570       };
31571     }
31572   }
31573
31574   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31575   return jresult;
31576 }
31577
31578
31579 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_1(unsigned int jarg1) {
31580   void * jresult ;
31581   unsigned int arg1 ;
31582   Dali::LongPressGestureDetector result;
31583
31584   arg1 = (unsigned int)jarg1;
31585   {
31586     try {
31587       result = Dali::LongPressGestureDetector::New(arg1);
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_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
31613   void * jresult ;
31614   unsigned int arg1 ;
31615   unsigned int arg2 ;
31616   Dali::LongPressGestureDetector result;
31617
31618   arg1 = (unsigned int)jarg1;
31619   arg2 = (unsigned int)jarg2;
31620   {
31621     try {
31622       result = Dali::LongPressGestureDetector::New(arg1,arg2);
31623     } catch (std::out_of_range& e) {
31624       {
31625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31626       };
31627     } catch (std::exception& e) {
31628       {
31629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31630       };
31631     } catch (Dali::DaliException e) {
31632       {
31633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31634       };
31635     } catch (...) {
31636       {
31637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31638       };
31639     }
31640   }
31641
31642   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31643   return jresult;
31644 }
31645
31646
31647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DownCast(void * jarg1) {
31648   void * jresult ;
31649   Dali::BaseHandle arg1 ;
31650   Dali::BaseHandle *argp1 ;
31651   Dali::LongPressGestureDetector result;
31652
31653   argp1 = (Dali::BaseHandle *)jarg1;
31654   if (!argp1) {
31655     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
31656     return 0;
31657   }
31658   arg1 = *argp1;
31659   {
31660     try {
31661       result = Dali::LongPressGestureDetector::DownCast(arg1);
31662     } catch (std::out_of_range& e) {
31663       {
31664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31665       };
31666     } catch (std::exception& e) {
31667       {
31668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31669       };
31670     } catch (Dali::DaliException e) {
31671       {
31672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31673       };
31674     } catch (...) {
31675       {
31676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31677       };
31678     }
31679   }
31680
31681   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31682   return jresult;
31683 }
31684
31685
31686 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetector(void * jarg1) {
31687   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31688
31689   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31690   {
31691     try {
31692       delete arg1;
31693     } catch (std::out_of_range& e) {
31694       {
31695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31696       };
31697     } catch (std::exception& e) {
31698       {
31699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31700       };
31701     } catch (Dali::DaliException e) {
31702       {
31703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31704       };
31705     } catch (...) {
31706       {
31707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31708       };
31709     }
31710   }
31711
31712 }
31713
31714
31715 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_1(void * jarg1) {
31716   void * jresult ;
31717   Dali::LongPressGestureDetector *arg1 = 0 ;
31718   Dali::LongPressGestureDetector *result = 0 ;
31719
31720   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31721   if (!arg1) {
31722     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
31723     return 0;
31724   }
31725   {
31726     try {
31727       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector((Dali::LongPressGestureDetector const &)*arg1);
31728     } catch (std::out_of_range& e) {
31729       {
31730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31731       };
31732     } catch (std::exception& e) {
31733       {
31734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31735       };
31736     } catch (Dali::DaliException e) {
31737       {
31738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31739       };
31740     } catch (...) {
31741       {
31742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31743       };
31744     }
31745   }
31746
31747   jresult = (void *)result;
31748   return jresult;
31749 }
31750
31751
31752 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_Assign(void * jarg1, void * jarg2) {
31753   void * jresult ;
31754   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31755   Dali::LongPressGestureDetector *arg2 = 0 ;
31756   Dali::LongPressGestureDetector *result = 0 ;
31757
31758   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31759   arg2 = (Dali::LongPressGestureDetector *)jarg2;
31760   if (!arg2) {
31761     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
31762     return 0;
31763   }
31764   {
31765     try {
31766       result = (Dali::LongPressGestureDetector *) &(arg1)->operator =((Dali::LongPressGestureDetector const &)*arg2);
31767     } catch (std::out_of_range& e) {
31768       {
31769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31770       };
31771     } catch (std::exception& e) {
31772       {
31773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31774       };
31775     } catch (Dali::DaliException e) {
31776       {
31777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31778       };
31779     } catch (...) {
31780       {
31781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31782       };
31783     }
31784   }
31785
31786   jresult = (void *)result;
31787   return jresult;
31788 }
31789
31790
31791 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_0(void * jarg1, unsigned int jarg2) {
31792   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31793   unsigned int arg2 ;
31794
31795   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31796   arg2 = (unsigned int)jarg2;
31797   {
31798     try {
31799       (arg1)->SetTouchesRequired(arg2);
31800     } catch (std::out_of_range& e) {
31801       {
31802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31803       };
31804     } catch (std::exception& e) {
31805       {
31806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31807       };
31808     } catch (Dali::DaliException e) {
31809       {
31810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31811       };
31812     } catch (...) {
31813       {
31814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31815       };
31816     }
31817   }
31818
31819 }
31820
31821
31822 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
31823   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31824   unsigned int arg2 ;
31825   unsigned int arg3 ;
31826
31827   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31828   arg2 = (unsigned int)jarg2;
31829   arg3 = (unsigned int)jarg3;
31830   {
31831     try {
31832       (arg1)->SetTouchesRequired(arg2,arg3);
31833     } catch (std::out_of_range& e) {
31834       {
31835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31836       };
31837     } catch (std::exception& e) {
31838       {
31839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31840       };
31841     } catch (Dali::DaliException e) {
31842       {
31843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31844       };
31845     } catch (...) {
31846       {
31847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31848       };
31849     }
31850   }
31851
31852 }
31853
31854
31855 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
31856   unsigned int jresult ;
31857   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31858   unsigned int result;
31859
31860   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31861   {
31862     try {
31863       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMinimumTouchesRequired();
31864     } catch (std::out_of_range& e) {
31865       {
31866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31867       };
31868     } catch (std::exception& e) {
31869       {
31870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31871       };
31872     } catch (Dali::DaliException e) {
31873       {
31874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31875       };
31876     } catch (...) {
31877       {
31878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31879       };
31880     }
31881   }
31882
31883   jresult = result;
31884   return jresult;
31885 }
31886
31887
31888 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
31889   unsigned int jresult ;
31890   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31891   unsigned int result;
31892
31893   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31894   {
31895     try {
31896       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMaximumTouchesRequired();
31897     } catch (std::out_of_range& e) {
31898       {
31899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31900       };
31901     } catch (std::exception& e) {
31902       {
31903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31904       };
31905     } catch (Dali::DaliException e) {
31906       {
31907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31908       };
31909     } catch (...) {
31910       {
31911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31912       };
31913     }
31914   }
31915
31916   jresult = result;
31917   return jresult;
31918 }
31919
31920
31921 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DetectedSignal(void * jarg1) {
31922   void * jresult ;
31923   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31924   Dali::LongPressGestureDetector::DetectedSignalType *result = 0 ;
31925
31926   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31927   {
31928     try {
31929       result = (Dali::LongPressGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
31930     } catch (std::out_of_range& e) {
31931       {
31932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31933       };
31934     } catch (std::exception& e) {
31935       {
31936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31937       };
31938     } catch (Dali::DaliException e) {
31939       {
31940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31941       };
31942     } catch (...) {
31943       {
31944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31945       };
31946     }
31947   }
31948
31949   jresult = (void *)result;
31950   return jresult;
31951 }
31952
31953
31954 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_0(int jarg1) {
31955   void * jresult ;
31956   Dali::Gesture::State arg1 ;
31957   Dali::LongPressGesture *result = 0 ;
31958
31959   arg1 = (Dali::Gesture::State)jarg1;
31960   {
31961     try {
31962       result = (Dali::LongPressGesture *)new Dali::LongPressGesture(arg1);
31963     } catch (std::out_of_range& e) {
31964       {
31965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31966       };
31967     } catch (std::exception& e) {
31968       {
31969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31970       };
31971     } catch (Dali::DaliException e) {
31972       {
31973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31974       };
31975     } catch (...) {
31976       {
31977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31978       };
31979     }
31980   }
31981
31982   jresult = (void *)result;
31983   return jresult;
31984 }
31985
31986
31987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_1(void * jarg1) {
31988   void * jresult ;
31989   Dali::LongPressGesture *arg1 = 0 ;
31990   Dali::LongPressGesture *result = 0 ;
31991
31992   arg1 = (Dali::LongPressGesture *)jarg1;
31993   if (!arg1) {
31994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
31995     return 0;
31996   }
31997   {
31998     try {
31999       result = (Dali::LongPressGesture *)new Dali::LongPressGesture((Dali::LongPressGesture const &)*arg1);
32000     } catch (std::out_of_range& e) {
32001       {
32002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32003       };
32004     } catch (std::exception& e) {
32005       {
32006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32007       };
32008     } catch (Dali::DaliException e) {
32009       {
32010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32011       };
32012     } catch (...) {
32013       {
32014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32015       };
32016     }
32017   }
32018
32019   jresult = (void *)result;
32020   return jresult;
32021 }
32022
32023
32024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_Assign(void * jarg1, void * jarg2) {
32025   void * jresult ;
32026   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32027   Dali::LongPressGesture *arg2 = 0 ;
32028   Dali::LongPressGesture *result = 0 ;
32029
32030   arg1 = (Dali::LongPressGesture *)jarg1;
32031   arg2 = (Dali::LongPressGesture *)jarg2;
32032   if (!arg2) {
32033     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
32034     return 0;
32035   }
32036   {
32037     try {
32038       result = (Dali::LongPressGesture *) &(arg1)->operator =((Dali::LongPressGesture const &)*arg2);
32039     } catch (std::out_of_range& e) {
32040       {
32041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32042       };
32043     } catch (std::exception& e) {
32044       {
32045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32046       };
32047     } catch (Dali::DaliException e) {
32048       {
32049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32050       };
32051     } catch (...) {
32052       {
32053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32054       };
32055     }
32056   }
32057
32058   jresult = (void *)result;
32059   return jresult;
32060 }
32061
32062
32063 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGesture(void * jarg1) {
32064   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32065
32066   arg1 = (Dali::LongPressGesture *)jarg1;
32067   {
32068     try {
32069       delete arg1;
32070     } catch (std::out_of_range& e) {
32071       {
32072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32073       };
32074     } catch (std::exception& e) {
32075       {
32076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32077       };
32078     } catch (Dali::DaliException e) {
32079       {
32080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32081       };
32082     } catch (...) {
32083       {
32084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32085       };
32086     }
32087   }
32088
32089 }
32090
32091
32092 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
32093   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32094   unsigned int arg2 ;
32095
32096   arg1 = (Dali::LongPressGesture *)jarg1;
32097   arg2 = (unsigned int)jarg2;
32098   if (arg1) (arg1)->numberOfTouches = arg2;
32099 }
32100
32101
32102 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_get(void * jarg1) {
32103   unsigned int jresult ;
32104   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32105   unsigned int result;
32106
32107   arg1 = (Dali::LongPressGesture *)jarg1;
32108   result = (unsigned int) ((arg1)->numberOfTouches);
32109   jresult = result;
32110   return jresult;
32111 }
32112
32113
32114 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_set(void * jarg1, void * jarg2) {
32115   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32116   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
32117
32118   arg1 = (Dali::LongPressGesture *)jarg1;
32119   arg2 = (Dali::Vector2 *)jarg2;
32120   if (arg1) (arg1)->screenPoint = *arg2;
32121 }
32122
32123
32124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_get(void * jarg1) {
32125   void * jresult ;
32126   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32127   Dali::Vector2 *result = 0 ;
32128
32129   arg1 = (Dali::LongPressGesture *)jarg1;
32130   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
32131   jresult = (void *)result;
32132   return jresult;
32133 }
32134
32135
32136 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_set(void * jarg1, void * jarg2) {
32137   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32138   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
32139
32140   arg1 = (Dali::LongPressGesture *)jarg1;
32141   arg2 = (Dali::Vector2 *)jarg2;
32142   if (arg1) (arg1)->localPoint = *arg2;
32143 }
32144
32145
32146 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_get(void * jarg1) {
32147   void * jresult ;
32148   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32149   Dali::Vector2 *result = 0 ;
32150
32151   arg1 = (Dali::LongPressGesture *)jarg1;
32152   result = (Dali::Vector2 *)& ((arg1)->localPoint);
32153   jresult = (void *)result;
32154   return jresult;
32155 }
32156
32157
32158 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_0() {
32159   void * jresult ;
32160   Dali::WheelEvent *result = 0 ;
32161
32162   {
32163     try {
32164       result = (Dali::WheelEvent *)new Dali::WheelEvent();
32165     } catch (std::out_of_range& e) {
32166       {
32167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32168       };
32169     } catch (std::exception& e) {
32170       {
32171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32172       };
32173     } catch (Dali::DaliException e) {
32174       {
32175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32176       };
32177     } catch (...) {
32178       {
32179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32180       };
32181     }
32182   }
32183
32184   jresult = (void *)result;
32185   return jresult;
32186 }
32187
32188
32189 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_1(int jarg1, int jarg2, unsigned int jarg3, void * jarg4, int jarg5, unsigned int jarg6) {
32190   void * jresult ;
32191   Dali::WheelEvent::Type arg1 ;
32192   int arg2 ;
32193   unsigned int arg3 ;
32194   Dali::Vector2 arg4 ;
32195   int arg5 ;
32196   unsigned int arg6 ;
32197   Dali::Vector2 *argp4 ;
32198   Dali::WheelEvent *result = 0 ;
32199
32200   arg1 = (Dali::WheelEvent::Type)jarg1;
32201   arg2 = (int)jarg2;
32202   arg3 = (unsigned int)jarg3;
32203   argp4 = (Dali::Vector2 *)jarg4;
32204   if (!argp4) {
32205     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
32206     return 0;
32207   }
32208   arg4 = *argp4;
32209   arg5 = (int)jarg5;
32210   arg6 = (unsigned int)jarg6;
32211   {
32212     try {
32213       result = (Dali::WheelEvent *)new Dali::WheelEvent(arg1,arg2,arg3,arg4,arg5,arg6);
32214     } catch (std::out_of_range& e) {
32215       {
32216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32217       };
32218     } catch (std::exception& e) {
32219       {
32220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32221       };
32222     } catch (Dali::DaliException e) {
32223       {
32224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32225       };
32226     } catch (...) {
32227       {
32228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32229       };
32230     }
32231   }
32232
32233   jresult = (void *)result;
32234   return jresult;
32235 }
32236
32237
32238 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Wheel(void * jarg1) {
32239   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32240
32241   arg1 = (Dali::WheelEvent *)jarg1;
32242   {
32243     try {
32244       delete arg1;
32245     } catch (std::out_of_range& e) {
32246       {
32247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32248       };
32249     } catch (std::exception& e) {
32250       {
32251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32252       };
32253     } catch (Dali::DaliException e) {
32254       {
32255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32256       };
32257     } catch (...) {
32258       {
32259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32260       };
32261     }
32262   }
32263
32264 }
32265
32266
32267 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsShiftModifier(void * jarg1) {
32268   unsigned int jresult ;
32269   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32270   bool result;
32271
32272   arg1 = (Dali::WheelEvent *)jarg1;
32273   {
32274     try {
32275       result = (bool)((Dali::WheelEvent const *)arg1)->IsShiftModifier();
32276     } catch (std::out_of_range& e) {
32277       {
32278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32279       };
32280     } catch (std::exception& e) {
32281       {
32282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32283       };
32284     } catch (Dali::DaliException e) {
32285       {
32286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32287       };
32288     } catch (...) {
32289       {
32290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32291       };
32292     }
32293   }
32294
32295   jresult = result;
32296   return jresult;
32297 }
32298
32299
32300 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsCtrlModifier(void * jarg1) {
32301   unsigned int jresult ;
32302   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32303   bool result;
32304
32305   arg1 = (Dali::WheelEvent *)jarg1;
32306   {
32307     try {
32308       result = (bool)((Dali::WheelEvent const *)arg1)->IsCtrlModifier();
32309     } catch (std::out_of_range& e) {
32310       {
32311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32312       };
32313     } catch (std::exception& e) {
32314       {
32315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32316       };
32317     } catch (Dali::DaliException e) {
32318       {
32319         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32320       };
32321     } catch (...) {
32322       {
32323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32324       };
32325     }
32326   }
32327
32328   jresult = result;
32329   return jresult;
32330 }
32331
32332
32333 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsAltModifier(void * jarg1) {
32334   unsigned int jresult ;
32335   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32336   bool result;
32337
32338   arg1 = (Dali::WheelEvent *)jarg1;
32339   {
32340     try {
32341       result = (bool)((Dali::WheelEvent const *)arg1)->IsAltModifier();
32342     } catch (std::out_of_range& e) {
32343       {
32344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32345       };
32346     } catch (std::exception& e) {
32347       {
32348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32349       };
32350     } catch (Dali::DaliException e) {
32351       {
32352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32353       };
32354     } catch (...) {
32355       {
32356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32357       };
32358     }
32359   }
32360
32361   jresult = result;
32362   return jresult;
32363 }
32364
32365
32366 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_type_set(void * jarg1, int jarg2) {
32367   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32368   Dali::WheelEvent::Type arg2 ;
32369
32370   arg1 = (Dali::WheelEvent *)jarg1;
32371   arg2 = (Dali::WheelEvent::Type)jarg2;
32372   if (arg1) (arg1)->type = arg2;
32373 }
32374
32375
32376 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_type_get(void * jarg1) {
32377   int jresult ;
32378   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32379   Dali::WheelEvent::Type result;
32380
32381   arg1 = (Dali::WheelEvent *)jarg1;
32382   result = (Dali::WheelEvent::Type) ((arg1)->type);
32383   jresult = (int)result;
32384   return jresult;
32385 }
32386
32387
32388 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_direction_set(void * jarg1, int jarg2) {
32389   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32390   int arg2 ;
32391
32392   arg1 = (Dali::WheelEvent *)jarg1;
32393   arg2 = (int)jarg2;
32394   if (arg1) (arg1)->direction = arg2;
32395 }
32396
32397
32398 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_direction_get(void * jarg1) {
32399   int jresult ;
32400   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32401   int result;
32402
32403   arg1 = (Dali::WheelEvent *)jarg1;
32404   result = (int) ((arg1)->direction);
32405   jresult = result;
32406   return jresult;
32407 }
32408
32409
32410 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_modifiers_set(void * jarg1, unsigned int jarg2) {
32411   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32412   unsigned int arg2 ;
32413
32414   arg1 = (Dali::WheelEvent *)jarg1;
32415   arg2 = (unsigned int)jarg2;
32416   if (arg1) (arg1)->modifiers = arg2;
32417 }
32418
32419
32420 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_modifiers_get(void * jarg1) {
32421   unsigned int jresult ;
32422   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32423   unsigned int result;
32424
32425   arg1 = (Dali::WheelEvent *)jarg1;
32426   result = (unsigned int) ((arg1)->modifiers);
32427   jresult = result;
32428   return jresult;
32429 }
32430
32431
32432 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_point_set(void * jarg1, void * jarg2) {
32433   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32434   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
32435
32436   arg1 = (Dali::WheelEvent *)jarg1;
32437   arg2 = (Dali::Vector2 *)jarg2;
32438   if (arg1) (arg1)->point = *arg2;
32439 }
32440
32441
32442 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_point_get(void * jarg1) {
32443   void * jresult ;
32444   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32445   Dali::Vector2 *result = 0 ;
32446
32447   arg1 = (Dali::WheelEvent *)jarg1;
32448   result = (Dali::Vector2 *)& ((arg1)->point);
32449   jresult = (void *)result;
32450   return jresult;
32451 }
32452
32453
32454 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_z_set(void * jarg1, int jarg2) {
32455   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32456   int arg2 ;
32457
32458   arg1 = (Dali::WheelEvent *)jarg1;
32459   arg2 = (int)jarg2;
32460   if (arg1) (arg1)->z = arg2;
32461 }
32462
32463
32464 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_z_get(void * jarg1) {
32465   int jresult ;
32466   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32467   int result;
32468
32469   arg1 = (Dali::WheelEvent *)jarg1;
32470   result = (int) ((arg1)->z);
32471   jresult = result;
32472   return jresult;
32473 }
32474
32475
32476 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_set(void * jarg1, unsigned int jarg2) {
32477   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32478   unsigned int arg2 ;
32479
32480   arg1 = (Dali::WheelEvent *)jarg1;
32481   arg2 = (unsigned int)jarg2;
32482   if (arg1) (arg1)->timeStamp = arg2;
32483 }
32484
32485
32486 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_get(void * jarg1) {
32487   unsigned int jresult ;
32488   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32489   unsigned int result;
32490
32491   arg1 = (Dali::WheelEvent *)jarg1;
32492   result = (unsigned int) ((arg1)->timeStamp);
32493   jresult = result;
32494   return jresult;
32495 }
32496
32497 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetDeviceName(void * jarg1) {
32498   char * jresult ;
32499   Dali::KeyEvent *arg1 = 0 ;
32500   std::string result;
32501
32502   arg1 = (Dali::KeyEvent *)jarg1;
32503   if (!arg1) {
32504     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32505     return 0;
32506   }
32507   {
32508     try {
32509       result = arg1->GetDeviceName();
32510     } catch (std::out_of_range& e) {
32511       {
32512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32513       };
32514     } catch (std::exception& e) {
32515       {
32516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32517       };
32518     } catch (Dali::DaliException e) {
32519       {
32520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32521       };
32522     } catch (...) {
32523       {
32524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32525       };
32526     }
32527   }
32528
32529   jresult = SWIG_csharp_string_callback((&result)->c_str());
32530   return jresult;
32531 }
32532
32533 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceClass(void * jarg1) {
32534   int jresult ;
32535   Dali::KeyEvent *arg1 = 0 ;
32536   Dali::Device::Class::Type result;
32537
32538   arg1 = (Dali::KeyEvent *)jarg1;
32539   if (!arg1) {
32540     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32541     return 0;
32542   }
32543   {
32544     try {
32545       result = (Dali::Device::Class::Type)arg1->GetDeviceClass();
32546     } catch (std::out_of_range& e) {
32547       {
32548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32549       };
32550     } catch (std::exception& e) {
32551       {
32552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32553       };
32554     } catch (Dali::DaliException e) {
32555       {
32556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32557       };
32558     } catch (...) {
32559       {
32560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32561       };
32562     }
32563   }
32564
32565   jresult = (int)result;
32566   return jresult;
32567 }
32568
32569 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceSubClass(void * jarg1) {
32570   int jresult ;
32571   Dali::KeyEvent *arg1 = 0 ;
32572   Dali::Device::Subclass::Type result;
32573
32574   arg1 = (Dali::KeyEvent *)jarg1;
32575   if (!arg1) {
32576     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32577     return 0;
32578   }
32579   {
32580     try {
32581       result = (Dali::Device::Subclass::Type)arg1->GetDeviceSubclass();
32582     } catch (std::out_of_range& e) {
32583       {
32584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32585       };
32586     } catch (std::exception& e) {
32587       {
32588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32589       };
32590     } catch (Dali::DaliException e) {
32591       {
32592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32593       };
32594     } catch (...) {
32595       {
32596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32597       };
32598     }
32599   }
32600
32601   jresult = (int)result;
32602   return jresult;
32603 }
32604
32605 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Raise(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.Raise();
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_Lower(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.Lower();
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_RaiseToTop(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.RaiseToTop();
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_LowerToBottom(void * jarg1) {
32711   Dali::Actor arg1 ;
32712   Dali::Actor *argp1 ;
32713
32714   argp1 = (Dali::Actor *)jarg1;
32715   if (!argp1) {
32716     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32717     return ;
32718   }
32719   arg1 = *argp1;
32720   {
32721     try {
32722       arg1.LowerToBottom();
32723     } catch (std::out_of_range& e) {
32724       {
32725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32726       };
32727     } catch (std::exception& e) {
32728       {
32729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32730       };
32731     } catch (Dali::DaliException e) {
32732       {
32733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32734       };
32735     } catch (...) {
32736       {
32737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32738       };
32739     }
32740   }
32741
32742 }
32743
32744 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseAbove(void * jarg1, void * jarg2) {
32745   Dali::Actor arg1 ;
32746   Dali::Actor arg2 ;
32747   Dali::Actor *argp1 ;
32748   Dali::Actor *argp2 ;
32749
32750   argp1 = (Dali::Actor *)jarg1;
32751   if (!argp1) {
32752     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32753     return ;
32754   }
32755   arg1 = *argp1;
32756   argp2 = (Dali::Actor *)jarg2;
32757   if (!argp2) {
32758     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32759     return ;
32760   }
32761   arg2 = *argp2;
32762   {
32763     try {
32764       arg1.RaiseAbove(arg2);
32765     } catch (std::out_of_range& e) {
32766       {
32767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32768       };
32769     } catch (std::exception& e) {
32770       {
32771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32772       };
32773     } catch (Dali::DaliException e) {
32774       {
32775         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32776       };
32777     } catch (...) {
32778       {
32779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32780       };
32781     }
32782   }
32783
32784 }
32785
32786
32787 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerBelow(void * jarg1, void * jarg2) {
32788   Dali::Actor arg1 ;
32789   Dali::Actor arg2 ;
32790   Dali::Actor *argp1 ;
32791   Dali::Actor *argp2 ;
32792
32793   argp1 = (Dali::Actor *)jarg1;
32794   if (!argp1) {
32795     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32796     return ;
32797   }
32798   arg1 = *argp1;
32799   argp2 = (Dali::Actor *)jarg2;
32800   if (!argp2) {
32801     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32802     return ;
32803   }
32804   arg2 = *argp2;
32805   {
32806     try {
32807       arg1.LowerBelow(arg2);
32808     } catch (std::out_of_range& e) {
32809       {
32810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32811       };
32812     } catch (std::exception& e) {
32813       {
32814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32815       };
32816     } catch (Dali::DaliException e) {
32817       {
32818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32819       };
32820     } catch (...) {
32821       {
32822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32823       };
32824     }
32825   }
32826
32827 }
32828
32829
32830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisibilityChangedSignal(void * jarg1) {
32831   void * jresult ;
32832   Dali::Actor arg1 ;
32833   Dali::Actor *argp1 ;
32834   Dali::DevelActor::VisibilityChangedSignalType *result = 0 ;
32835
32836   argp1 = (Dali::Actor *)jarg1;
32837   if (!argp1) {
32838     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32839     return 0;
32840   }
32841   arg1 = *argp1;
32842   {
32843     try {
32844       result = (Dali::DevelActor::VisibilityChangedSignalType *) &Dali::DevelActor::VisibilityChangedSignal(arg1);
32845     } catch (std::out_of_range& e) {
32846       {
32847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32848       };
32849     } catch (std::exception& e) {
32850       {
32851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32852       };
32853     } catch (Dali::DaliException e) {
32854       {
32855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32856       };
32857     } catch (...) {
32858       {
32859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32860       };
32861     }
32862   }
32863
32864   jresult = (void *)result;
32865   return jresult;
32866 }
32867
32868
32869 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutDirectionChangedSignal(void * jarg1) {
32870   void * jresult ;
32871   Dali::Actor *arg1 ;
32872   Dali::Actor::LayoutDirectionChangedSignalType *result = 0 ;
32873
32874   arg1 = (Dali::Actor *)jarg1;
32875   {
32876     try {
32877       result = (Dali::Actor::LayoutDirectionChangedSignalType *) &(arg1)->LayoutDirectionChangedSignal();
32878     } catch (std::out_of_range& e) {
32879       {
32880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32881       };
32882     } catch (std::exception& e) {
32883       {
32884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32885       };
32886     } catch (Dali::DaliException e) {
32887       {
32888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32889       };
32890     } catch (...) {
32891       {
32892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32893       };
32894     }
32895   }
32896
32897   jresult = (void *)result;
32898   return jresult;
32899 }
32900
32901
32902 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_get() {
32903   int jresult ;
32904   int result;
32905
32906   result = (int)Dali::Actor::Property::PARENT_ORIGIN;
32907   jresult = (int)result;
32908   return jresult;
32909 }
32910
32911
32912 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_X_get() {
32913   int jresult ;
32914   int result;
32915
32916   result = (int)Dali::Actor::Property::PARENT_ORIGIN_X;
32917   jresult = (int)result;
32918   return jresult;
32919 }
32920
32921
32922 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Y_get() {
32923   int jresult ;
32924   int result;
32925
32926   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Y;
32927   jresult = (int)result;
32928   return jresult;
32929 }
32930
32931
32932 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Z_get() {
32933   int jresult ;
32934   int result;
32935
32936   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Z;
32937   jresult = (int)result;
32938   return jresult;
32939 }
32940
32941
32942 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_get() {
32943   int jresult ;
32944   int result;
32945
32946   result = (int)Dali::Actor::Property::ANCHOR_POINT;
32947   jresult = (int)result;
32948   return jresult;
32949 }
32950
32951
32952 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_X_get() {
32953   int jresult ;
32954   int result;
32955
32956   result = (int)Dali::Actor::Property::ANCHOR_POINT_X;
32957   jresult = (int)result;
32958   return jresult;
32959 }
32960
32961
32962 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Y_get() {
32963   int jresult ;
32964   int result;
32965
32966   result = (int)Dali::Actor::Property::ANCHOR_POINT_Y;
32967   jresult = (int)result;
32968   return jresult;
32969 }
32970
32971
32972 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Z_get() {
32973   int jresult ;
32974   int result;
32975
32976   result = (int)Dali::Actor::Property::ANCHOR_POINT_Z;
32977   jresult = (int)result;
32978   return jresult;
32979 }
32980
32981
32982 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_get() {
32983   int jresult ;
32984   int result;
32985
32986   result = (int)Dali::Actor::Property::SIZE;
32987   jresult = (int)result;
32988   return jresult;
32989 }
32990
32991
32992 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_WIDTH_get() {
32993   int jresult ;
32994   int result;
32995
32996   result = (int)Dali::Actor::Property::SIZE_WIDTH;
32997   jresult = (int)result;
32998   return jresult;
32999 }
33000
33001
33002 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_HEIGHT_get() {
33003   int jresult ;
33004   int result;
33005
33006   result = (int)Dali::Actor::Property::SIZE_HEIGHT;
33007   jresult = (int)result;
33008   return jresult;
33009 }
33010
33011
33012 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_DEPTH_get() {
33013   int jresult ;
33014   int result;
33015
33016   result = (int)Dali::Actor::Property::SIZE_DEPTH;
33017   jresult = (int)result;
33018   return jresult;
33019 }
33020
33021
33022 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_get() {
33023   int jresult ;
33024   int result;
33025
33026   result = (int)Dali::Actor::Property::POSITION;
33027   jresult = (int)result;
33028   return jresult;
33029 }
33030
33031
33032 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_X_get() {
33033   int jresult ;
33034   int result;
33035
33036   result = (int)Dali::Actor::Property::POSITION_X;
33037   jresult = (int)result;
33038   return jresult;
33039 }
33040
33041
33042 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Y_get() {
33043   int jresult ;
33044   int result;
33045
33046   result = (int)Dali::Actor::Property::POSITION_Y;
33047   jresult = (int)result;
33048   return jresult;
33049 }
33050
33051
33052 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Z_get() {
33053   int jresult ;
33054   int result;
33055
33056   result = (int)Dali::Actor::Property::POSITION_Z;
33057   jresult = (int)result;
33058   return jresult;
33059 }
33060
33061
33062 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_get() {
33063   int jresult ;
33064   int result;
33065
33066   result = (int)Dali::Actor::Property::WORLD_POSITION;
33067   jresult = (int)result;
33068   return jresult;
33069 }
33070
33071
33072 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_X_get() {
33073   int jresult ;
33074   int result;
33075
33076   result = (int)Dali::Actor::Property::WORLD_POSITION_X;
33077   jresult = (int)result;
33078   return jresult;
33079 }
33080
33081
33082 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Y_get() {
33083   int jresult ;
33084   int result;
33085
33086   result = (int)Dali::Actor::Property::WORLD_POSITION_Y;
33087   jresult = (int)result;
33088   return jresult;
33089 }
33090
33091
33092 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Z_get() {
33093   int jresult ;
33094   int result;
33095
33096   result = (int)Dali::Actor::Property::WORLD_POSITION_Z;
33097   jresult = (int)result;
33098   return jresult;
33099 }
33100
33101
33102 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ORIENTATION_get() {
33103   int jresult ;
33104   int result;
33105
33106   result = (int)Dali::Actor::Property::ORIENTATION;
33107   jresult = (int)result;
33108   return jresult;
33109 }
33110
33111
33112 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_ORIENTATION_get() {
33113   int jresult ;
33114   int result;
33115
33116   result = (int)Dali::Actor::Property::WORLD_ORIENTATION;
33117   jresult = (int)result;
33118   return jresult;
33119 }
33120
33121
33122 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_get() {
33123   int jresult ;
33124   int result;
33125
33126   result = (int)Dali::Actor::Property::SCALE;
33127   jresult = (int)result;
33128   return jresult;
33129 }
33130
33131
33132 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_X_get() {
33133   int jresult ;
33134   int result;
33135
33136   result = (int)Dali::Actor::Property::SCALE_X;
33137   jresult = (int)result;
33138   return jresult;
33139 }
33140
33141
33142 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Y_get() {
33143   int jresult ;
33144   int result;
33145
33146   result = (int)Dali::Actor::Property::SCALE_Y;
33147   jresult = (int)result;
33148   return jresult;
33149 }
33150
33151
33152 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Z_get() {
33153   int jresult ;
33154   int result;
33155
33156   result = (int)Dali::Actor::Property::SCALE_Z;
33157   jresult = (int)result;
33158   return jresult;
33159 }
33160
33161
33162 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_SCALE_get() {
33163   int jresult ;
33164   int result;
33165
33166   result = (int)Dali::Actor::Property::WORLD_SCALE;
33167   jresult = (int)result;
33168   return jresult;
33169 }
33170
33171
33172 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_VISIBLE_get() {
33173   int jresult ;
33174   int result;
33175
33176   result = (int)Dali::Actor::Property::VISIBLE;
33177   jresult = (int)result;
33178   return jresult;
33179 }
33180
33181
33182 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_get() {
33183   int jresult ;
33184   int result;
33185
33186   result = (int)Dali::Actor::Property::COLOR;
33187   jresult = (int)result;
33188   return jresult;
33189 }
33190
33191
33192 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_RED_get() {
33193   int jresult ;
33194   int result;
33195
33196   result = (int)Dali::Actor::Property::COLOR_RED;
33197   jresult = (int)result;
33198   return jresult;
33199 }
33200
33201
33202 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_GREEN_get() {
33203   int jresult ;
33204   int result;
33205
33206   result = (int)Dali::Actor::Property::COLOR_GREEN;
33207   jresult = (int)result;
33208   return jresult;
33209 }
33210
33211
33212 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_BLUE_get() {
33213   int jresult ;
33214   int result;
33215
33216   result = (int)Dali::Actor::Property::COLOR_BLUE;
33217   jresult = (int)result;
33218   return jresult;
33219 }
33220
33221
33222 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_ALPHA_get() {
33223   int jresult ;
33224   int result;
33225
33226   result = (int)Dali::Actor::Property::COLOR_ALPHA;
33227   jresult = (int)result;
33228   return jresult;
33229 }
33230
33231
33232 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_COLOR_get() {
33233   int jresult ;
33234   int result;
33235
33236   result = (int)Dali::Actor::Property::WORLD_COLOR;
33237   jresult = (int)result;
33238   return jresult;
33239 }
33240
33241
33242 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_MATRIX_get() {
33243   int jresult ;
33244   int result;
33245
33246   result = (int)Dali::Actor::Property::WORLD_MATRIX;
33247   jresult = (int)result;
33248   return jresult;
33249 }
33250
33251
33252 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_NAME_get() {
33253   int jresult ;
33254   int result;
33255
33256   result = (int)Dali::Actor::Property::NAME;
33257   jresult = (int)result;
33258   return jresult;
33259 }
33260
33261
33262 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SENSITIVE_get() {
33263   int jresult ;
33264   int result;
33265
33266   result = (int)Dali::Actor::Property::SENSITIVE;
33267   jresult = (int)result;
33268   return jresult;
33269 }
33270
33271
33272 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_LEAVE_REQUIRED_get() {
33273   int jresult ;
33274   int result;
33275
33276   result = (int)Dali::Actor::Property::LEAVE_REQUIRED;
33277   jresult = (int)result;
33278   return jresult;
33279 }
33280
33281
33282 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_ORIENTATION_get() {
33283   int jresult ;
33284   int result;
33285
33286   result = (int)Dali::Actor::Property::INHERIT_ORIENTATION;
33287   jresult = (int)result;
33288   return jresult;
33289 }
33290
33291
33292 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_SCALE_get() {
33293   int jresult ;
33294   int result;
33295
33296   result = (int)Dali::Actor::Property::INHERIT_SCALE;
33297   jresult = (int)result;
33298   return jresult;
33299 }
33300
33301
33302 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_MODE_get() {
33303   int jresult ;
33304   int result;
33305
33306   result = (int)Dali::Actor::Property::COLOR_MODE;
33307   jresult = (int)result;
33308   return jresult;
33309 }
33310
33311
33312 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_INHERITANCE_get() {
33313   int jresult ;
33314   int result;
33315
33316   result = (int)Dali::Actor::Property::POSITION_INHERITANCE;
33317   jresult = (int)result;
33318   return jresult;
33319 }
33320
33321
33322 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_DRAW_MODE_get() {
33323   int jresult ;
33324   int result;
33325
33326   result = (int)Dali::Actor::Property::DRAW_MODE;
33327   jresult = (int)result;
33328   return jresult;
33329 }
33330
33331
33332 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_MODE_FACTOR_get() {
33333   int jresult ;
33334   int result;
33335
33336   result = (int)Dali::Actor::Property::SIZE_MODE_FACTOR;
33337   jresult = (int)result;
33338   return jresult;
33339 }
33340
33341
33342 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_RESIZE_POLICY_get() {
33343   int jresult ;
33344   int result;
33345
33346   result = (int)Dali::Actor::Property::WIDTH_RESIZE_POLICY;
33347   jresult = (int)result;
33348   return jresult;
33349 }
33350
33351
33352 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_RESIZE_POLICY_get() {
33353   int jresult ;
33354   int result;
33355
33356   result = (int)Dali::Actor::Property::HEIGHT_RESIZE_POLICY;
33357   jresult = (int)result;
33358   return jresult;
33359 }
33360
33361
33362 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_SCALE_POLICY_get() {
33363   int jresult ;
33364   int result;
33365
33366   result = (int)Dali::Actor::Property::SIZE_SCALE_POLICY;
33367   jresult = (int)result;
33368   return jresult;
33369 }
33370
33371
33372 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_FOR_HEIGHT_get() {
33373   int jresult ;
33374   int result;
33375
33376   result = (int)Dali::Actor::Property::WIDTH_FOR_HEIGHT;
33377   jresult = (int)result;
33378   return jresult;
33379 }
33380
33381
33382 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_FOR_WIDTH_get() {
33383   int jresult ;
33384   int result;
33385
33386   result = (int)Dali::Actor::Property::HEIGHT_FOR_WIDTH;
33387   jresult = (int)result;
33388   return jresult;
33389 }
33390
33391
33392 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PADDING_get() {
33393   int jresult ;
33394   int result;
33395
33396   result = (int)Dali::Actor::Property::PADDING;
33397   jresult = (int)result;
33398   return jresult;
33399 }
33400
33401
33402 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MINIMUM_SIZE_get() {
33403   int jresult ;
33404   int result;
33405
33406   result = (int)Dali::Actor::Property::MINIMUM_SIZE;
33407   jresult = (int)result;
33408   return jresult;
33409 }
33410
33411
33412 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MAXIMUM_SIZE_get() {
33413   int jresult ;
33414   int result;
33415
33416   result = (int)Dali::Actor::Property::MAXIMUM_SIZE;
33417   jresult = (int)result;
33418   return jresult;
33419 }
33420
33421
33422 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_POSITION_get() {
33423   int jresult ;
33424   int result;
33425
33426   result = (int)Dali::Actor::Property::INHERIT_POSITION;
33427   jresult = (int)result;
33428   return jresult;
33429 }
33430
33431
33432 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_CLIPPING_MODE_get() {
33433   int jresult ;
33434   int result;
33435
33436   result = (int)Dali::Actor::Property::CLIPPING_MODE;
33437   jresult = (int)result;
33438   return jresult;
33439 }
33440
33441
33442 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor_Property() {
33443   void * jresult ;
33444   Dali::Actor::Property *result = 0 ;
33445
33446   {
33447     try {
33448       result = (Dali::Actor::Property *)new Dali::Actor::Property();
33449     } catch (std::out_of_range& e) {
33450       {
33451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33452       };
33453     } catch (std::exception& e) {
33454       {
33455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33456       };
33457     } catch (Dali::DaliException e) {
33458       {
33459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33460       };
33461     } catch (...) {
33462       {
33463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33464       };
33465     }
33466   }
33467
33468   jresult = (void *)result;
33469   return jresult;
33470 }
33471
33472
33473 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor_Property(void * jarg1) {
33474   Dali::Actor::Property *arg1 = (Dali::Actor::Property *) 0 ;
33475
33476   arg1 = (Dali::Actor::Property *)jarg1;
33477   {
33478     try {
33479       delete arg1;
33480     } catch (std::out_of_range& e) {
33481       {
33482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33483       };
33484     } catch (std::exception& e) {
33485       {
33486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33487       };
33488     } catch (Dali::DaliException e) {
33489       {
33490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33491       };
33492     } catch (...) {
33493       {
33494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33495       };
33496     }
33497   }
33498
33499 }
33500
33501
33502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_0() {
33503   void * jresult ;
33504   Dali::Actor *result = 0 ;
33505
33506   {
33507     try {
33508       result = (Dali::Actor *)new Dali::Actor();
33509     } catch (std::out_of_range& e) {
33510       {
33511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33512       };
33513     } catch (std::exception& e) {
33514       {
33515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33516       };
33517     } catch (Dali::DaliException e) {
33518       {
33519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33520       };
33521     } catch (...) {
33522       {
33523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33524       };
33525     }
33526   }
33527
33528   jresult = (void *)result;
33529   return jresult;
33530 }
33531
33532
33533 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_New() {
33534   void * jresult ;
33535   Dali::Actor result;
33536
33537   {
33538     try {
33539       result = Dali::Actor::New();
33540     } catch (std::out_of_range& e) {
33541       {
33542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33543       };
33544     } catch (std::exception& e) {
33545       {
33546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33547       };
33548     } catch (Dali::DaliException e) {
33549       {
33550         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33551       };
33552     } catch (...) {
33553       {
33554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33555       };
33556     }
33557   }
33558
33559   jresult = new Dali::Actor((const Dali::Actor &)result);
33560   return jresult;
33561 }
33562
33563
33564 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_DownCast(void * jarg1) {
33565   void * jresult ;
33566   Dali::BaseHandle arg1 ;
33567   Dali::BaseHandle *argp1 ;
33568   Dali::Actor result;
33569
33570   argp1 = (Dali::BaseHandle *)jarg1;
33571   if (!argp1) {
33572     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
33573     return 0;
33574   }
33575   arg1 = *argp1;
33576   {
33577     try {
33578       result = Dali::Actor::DownCast(arg1);
33579     } catch (std::out_of_range& e) {
33580       {
33581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33582       };
33583     } catch (std::exception& e) {
33584       {
33585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33586       };
33587     } catch (Dali::DaliException e) {
33588       {
33589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33590       };
33591     } catch (...) {
33592       {
33593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33594       };
33595     }
33596   }
33597
33598   jresult = new Dali::Actor((const Dali::Actor &)result);
33599   return jresult;
33600 }
33601
33602
33603 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor(void * jarg1) {
33604   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33605
33606   arg1 = (Dali::Actor *)jarg1;
33607   {
33608     try {
33609       delete arg1;
33610     } catch (std::out_of_range& e) {
33611       {
33612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33613       };
33614     } catch (std::exception& e) {
33615       {
33616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33617       };
33618     } catch (Dali::DaliException e) {
33619       {
33620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33621       };
33622     } catch (...) {
33623       {
33624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33625       };
33626     }
33627   }
33628
33629 }
33630
33631
33632 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_1(void * jarg1) {
33633   void * jresult ;
33634   Dali::Actor *arg1 = 0 ;
33635   Dali::Actor *result = 0 ;
33636
33637   arg1 = (Dali::Actor *)jarg1;
33638   if (!arg1) {
33639     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
33640     return 0;
33641   }
33642   {
33643     try {
33644       result = (Dali::Actor *)new Dali::Actor((Dali::Actor const &)*arg1);
33645     } catch (std::out_of_range& e) {
33646       {
33647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33648       };
33649     } catch (std::exception& e) {
33650       {
33651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33652       };
33653     } catch (Dali::DaliException e) {
33654       {
33655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33656       };
33657     } catch (...) {
33658       {
33659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33660       };
33661     }
33662   }
33663
33664   jresult = (void *)result;
33665   return jresult;
33666 }
33667
33668
33669 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_Assign(void * jarg1, void * jarg2) {
33670   void * jresult ;
33671   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33672   Dali::Actor *arg2 = 0 ;
33673   Dali::Actor *result = 0 ;
33674
33675   arg1 = (Dali::Actor *)jarg1;
33676   arg2 = (Dali::Actor *)jarg2;
33677   if (!arg2) {
33678     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
33679     return 0;
33680   }
33681   {
33682     try {
33683       result = (Dali::Actor *) &(arg1)->operator =((Dali::Actor const &)*arg2);
33684     } catch (std::out_of_range& e) {
33685       {
33686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33687       };
33688     } catch (std::exception& e) {
33689       {
33690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33691       };
33692     } catch (Dali::DaliException e) {
33693       {
33694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33695       };
33696     } catch (...) {
33697       {
33698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33699       };
33700     }
33701   }
33702
33703   jresult = (void *)result;
33704   return jresult;
33705 }
33706
33707
33708 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Actor_GetName(void * jarg1) {
33709   char * jresult ;
33710   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33711   std::string *result = 0 ;
33712
33713   arg1 = (Dali::Actor *)jarg1;
33714   {
33715     try {
33716       result = (std::string *) &((Dali::Actor const *)arg1)->GetName();
33717     } catch (std::out_of_range& e) {
33718       {
33719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33720       };
33721     } catch (std::exception& e) {
33722       {
33723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33724       };
33725     } catch (Dali::DaliException e) {
33726       {
33727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33728       };
33729     } catch (...) {
33730       {
33731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33732       };
33733     }
33734   }
33735
33736   jresult = SWIG_csharp_string_callback(result->c_str());
33737   return jresult;
33738 }
33739
33740
33741 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetName(void * jarg1, char * jarg2) {
33742   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33743   std::string *arg2 = 0 ;
33744
33745   arg1 = (Dali::Actor *)jarg1;
33746   if (!jarg2) {
33747     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
33748     return ;
33749   }
33750   std::string arg2_str(jarg2);
33751   arg2 = &arg2_str;
33752   {
33753     try {
33754       (arg1)->SetName((std::string const &)*arg2);
33755     } catch (std::out_of_range& e) {
33756       {
33757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33758       };
33759     } catch (std::exception& e) {
33760       {
33761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33762       };
33763     } catch (Dali::DaliException e) {
33764       {
33765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33766       };
33767     } catch (...) {
33768       {
33769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33770       };
33771     }
33772   }
33773
33774
33775   //argout typemap for const std::string&
33776
33777 }
33778
33779
33780 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetId(void * jarg1) {
33781   unsigned int jresult ;
33782   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33783   unsigned int result;
33784
33785   arg1 = (Dali::Actor *)jarg1;
33786   {
33787     try {
33788       result = (unsigned int)((Dali::Actor const *)arg1)->GetId();
33789     } catch (std::out_of_range& e) {
33790       {
33791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33792       };
33793     } catch (std::exception& e) {
33794       {
33795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33796       };
33797     } catch (Dali::DaliException e) {
33798       {
33799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33800       };
33801     } catch (...) {
33802       {
33803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33804       };
33805     }
33806   }
33807
33808   jresult = result;
33809   return jresult;
33810 }
33811
33812
33813 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsRoot(void * jarg1) {
33814   unsigned int jresult ;
33815   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33816   bool result;
33817
33818   arg1 = (Dali::Actor *)jarg1;
33819   {
33820     try {
33821       result = (bool)((Dali::Actor const *)arg1)->IsRoot();
33822     } catch (std::out_of_range& e) {
33823       {
33824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33825       };
33826     } catch (std::exception& e) {
33827       {
33828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33829       };
33830     } catch (Dali::DaliException e) {
33831       {
33832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33833       };
33834     } catch (...) {
33835       {
33836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33837       };
33838     }
33839   }
33840
33841   jresult = result;
33842   return jresult;
33843 }
33844
33845
33846 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_OnStage(void * jarg1) {
33847   unsigned int jresult ;
33848   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33849   bool result;
33850
33851   arg1 = (Dali::Actor *)jarg1;
33852   {
33853     try {
33854       result = (bool)((Dali::Actor const *)arg1)->OnStage();
33855     } catch (std::out_of_range& e) {
33856       {
33857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33858       };
33859     } catch (std::exception& e) {
33860       {
33861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33862       };
33863     } catch (Dali::DaliException e) {
33864       {
33865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33866       };
33867     } catch (...) {
33868       {
33869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33870       };
33871     }
33872   }
33873
33874   jresult = result;
33875   return jresult;
33876 }
33877
33878
33879 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsLayer(void * jarg1) {
33880   unsigned int jresult ;
33881   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33882   bool result;
33883
33884   arg1 = (Dali::Actor *)jarg1;
33885   {
33886     try {
33887       result = (bool)((Dali::Actor const *)arg1)->IsLayer();
33888     } catch (std::out_of_range& e) {
33889       {
33890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33891       };
33892     } catch (std::exception& e) {
33893       {
33894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33895       };
33896     } catch (Dali::DaliException e) {
33897       {
33898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33899       };
33900     } catch (...) {
33901       {
33902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33903       };
33904     }
33905   }
33906
33907   jresult = result;
33908   return jresult;
33909 }
33910
33911
33912 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetLayer(void * jarg1) {
33913   void * jresult ;
33914   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33915   Dali::Layer result;
33916
33917   arg1 = (Dali::Actor *)jarg1;
33918   {
33919     try {
33920       result = (arg1)->GetLayer();
33921     } catch (std::out_of_range& e) {
33922       {
33923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33924       };
33925     } catch (std::exception& e) {
33926       {
33927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33928       };
33929     } catch (Dali::DaliException e) {
33930       {
33931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33932       };
33933     } catch (...) {
33934       {
33935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33936       };
33937     }
33938   }
33939
33940   jresult = new Dali::Layer((const Dali::Layer &)result);
33941   return jresult;
33942 }
33943
33944
33945 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Add(void * jarg1, void * jarg2) {
33946   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33947   Dali::Actor arg2 ;
33948   Dali::Actor *argp2 ;
33949
33950   arg1 = (Dali::Actor *)jarg1;
33951   argp2 = (Dali::Actor *)jarg2;
33952   if (!argp2) {
33953     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
33954     return ;
33955   }
33956   arg2 = *argp2;
33957   {
33958     try {
33959       (arg1)->Add(arg2);
33960     } catch (std::out_of_range& e) {
33961       {
33962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33963       };
33964     } catch (std::exception& e) {
33965       {
33966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33967       };
33968     } catch (Dali::DaliException e) {
33969       {
33970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33971       };
33972     } catch (...) {
33973       {
33974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33975       };
33976     }
33977   }
33978
33979 }
33980
33981
33982 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Remove(void * jarg1, void * jarg2) {
33983   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33984   Dali::Actor arg2 ;
33985   Dali::Actor *argp2 ;
33986
33987   arg1 = (Dali::Actor *)jarg1;
33988   argp2 = (Dali::Actor *)jarg2;
33989   if (!argp2) {
33990     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
33991     return ;
33992   }
33993   arg2 = *argp2;
33994   {
33995     try {
33996       (arg1)->Remove(arg2);
33997     } catch (std::out_of_range& e) {
33998       {
33999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34000       };
34001     } catch (std::exception& e) {
34002       {
34003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34004       };
34005     } catch (Dali::DaliException e) {
34006       {
34007         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34008       };
34009     } catch (...) {
34010       {
34011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34012       };
34013     }
34014   }
34015
34016 }
34017
34018
34019 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Unparent(void * jarg1) {
34020   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34021
34022   arg1 = (Dali::Actor *)jarg1;
34023   {
34024     try {
34025       (arg1)->Unparent();
34026     } catch (std::out_of_range& e) {
34027       {
34028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34029       };
34030     } catch (std::exception& e) {
34031       {
34032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34033       };
34034     } catch (Dali::DaliException e) {
34035       {
34036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34037       };
34038     } catch (...) {
34039       {
34040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34041       };
34042     }
34043   }
34044
34045 }
34046
34047
34048 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetChildCount(void * jarg1) {
34049   unsigned int jresult ;
34050   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34051   unsigned int result;
34052
34053   arg1 = (Dali::Actor *)jarg1;
34054   {
34055     try {
34056       result = (unsigned int)((Dali::Actor const *)arg1)->GetChildCount();
34057     } catch (std::out_of_range& e) {
34058       {
34059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34060       };
34061     } catch (std::exception& e) {
34062       {
34063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34064       };
34065     } catch (Dali::DaliException e) {
34066       {
34067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34068       };
34069     } catch (...) {
34070       {
34071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34072       };
34073     }
34074   }
34075
34076   jresult = result;
34077   return jresult;
34078 }
34079
34080
34081 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetChildAt(void * jarg1, unsigned int jarg2) {
34082   void * jresult ;
34083   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34084   unsigned int arg2 ;
34085   Dali::Actor result;
34086
34087   arg1 = (Dali::Actor *)jarg1;
34088   arg2 = (unsigned int)jarg2;
34089   {
34090     try {
34091       result = ((Dali::Actor const *)arg1)->GetChildAt(arg2);
34092     } catch (std::out_of_range& e) {
34093       {
34094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34095       };
34096     } catch (std::exception& e) {
34097       {
34098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34099       };
34100     } catch (Dali::DaliException e) {
34101       {
34102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34103       };
34104     } catch (...) {
34105       {
34106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34107       };
34108     }
34109   }
34110
34111   jresult = new Dali::Actor((const Dali::Actor &)result);
34112   return jresult;
34113 }
34114
34115
34116 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildByName(void * jarg1, char * jarg2) {
34117   void * jresult ;
34118   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34119   std::string *arg2 = 0 ;
34120   Dali::Actor result;
34121
34122   arg1 = (Dali::Actor *)jarg1;
34123   if (!jarg2) {
34124     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
34125     return 0;
34126   }
34127   std::string arg2_str(jarg2);
34128   arg2 = &arg2_str;
34129   {
34130     try {
34131       result = (arg1)->FindChildByName((std::string const &)*arg2);
34132     } catch (std::out_of_range& e) {
34133       {
34134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34135       };
34136     } catch (std::exception& e) {
34137       {
34138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34139       };
34140     } catch (Dali::DaliException e) {
34141       {
34142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34143       };
34144     } catch (...) {
34145       {
34146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34147       };
34148     }
34149   }
34150
34151   jresult = new Dali::Actor((const Dali::Actor &)result);
34152
34153   //argout typemap for const std::string&
34154
34155   return jresult;
34156 }
34157
34158
34159 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildById(void * jarg1, unsigned int jarg2) {
34160   void * jresult ;
34161   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34162   unsigned int arg2 ;
34163   Dali::Actor result;
34164
34165   arg1 = (Dali::Actor *)jarg1;
34166   arg2 = (unsigned int)jarg2;
34167   {
34168     try {
34169       result = (arg1)->FindChildById(arg2);
34170     } catch (std::out_of_range& e) {
34171       {
34172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34173       };
34174     } catch (std::exception& e) {
34175       {
34176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34177       };
34178     } catch (Dali::DaliException e) {
34179       {
34180         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34181       };
34182     } catch (...) {
34183       {
34184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34185       };
34186     }
34187   }
34188
34189   jresult = new Dali::Actor((const Dali::Actor &)result);
34190   return jresult;
34191 }
34192
34193
34194 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetParent(void * jarg1) {
34195   void * jresult ;
34196   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34197   Dali::Actor result;
34198
34199   arg1 = (Dali::Actor *)jarg1;
34200   {
34201     try {
34202       result = ((Dali::Actor const *)arg1)->GetParent();
34203     } catch (std::out_of_range& e) {
34204       {
34205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34206       };
34207     } catch (std::exception& e) {
34208       {
34209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34210       };
34211     } catch (Dali::DaliException e) {
34212       {
34213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34214       };
34215     } catch (...) {
34216       {
34217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34218       };
34219     }
34220   }
34221
34222   jresult = new Dali::Actor((const Dali::Actor &)result);
34223   return jresult;
34224 }
34225
34226
34227 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetParentOrigin(void * jarg1, void * jarg2) {
34228   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34229   Dali::Vector3 *arg2 = 0 ;
34230
34231   arg1 = (Dali::Actor *)jarg1;
34232   arg2 = (Dali::Vector3 *)jarg2;
34233   if (!arg2) {
34234     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34235     return ;
34236   }
34237   {
34238     try {
34239       (arg1)->SetParentOrigin((Dali::Vector3 const &)*arg2);
34240     } catch (std::out_of_range& e) {
34241       {
34242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34243       };
34244     } catch (std::exception& e) {
34245       {
34246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34247       };
34248     } catch (Dali::DaliException e) {
34249       {
34250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34251       };
34252     } catch (...) {
34253       {
34254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34255       };
34256     }
34257   }
34258
34259 }
34260
34261
34262 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentParentOrigin(void * jarg1) {
34263   void * jresult ;
34264   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34265   Dali::Vector3 result;
34266
34267   arg1 = (Dali::Actor *)jarg1;
34268   {
34269     try {
34270       result = ((Dali::Actor const *)arg1)->GetCurrentParentOrigin();
34271     } catch (std::out_of_range& e) {
34272       {
34273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34274       };
34275     } catch (std::exception& e) {
34276       {
34277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34278       };
34279     } catch (Dali::DaliException e) {
34280       {
34281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34282       };
34283     } catch (...) {
34284       {
34285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34286       };
34287     }
34288   }
34289
34290   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34291   return jresult;
34292 }
34293
34294
34295 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetAnchorPoint(void * jarg1, void * jarg2) {
34296   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34297   Dali::Vector3 *arg2 = 0 ;
34298
34299   arg1 = (Dali::Actor *)jarg1;
34300   arg2 = (Dali::Vector3 *)jarg2;
34301   if (!arg2) {
34302     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34303     return ;
34304   }
34305   {
34306     try {
34307       (arg1)->SetAnchorPoint((Dali::Vector3 const &)*arg2);
34308     } catch (std::out_of_range& e) {
34309       {
34310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34311       };
34312     } catch (std::exception& e) {
34313       {
34314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34315       };
34316     } catch (Dali::DaliException e) {
34317       {
34318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34319       };
34320     } catch (...) {
34321       {
34322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34323       };
34324     }
34325   }
34326
34327 }
34328
34329
34330 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentAnchorPoint(void * jarg1) {
34331   void * jresult ;
34332   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34333   Dali::Vector3 result;
34334
34335   arg1 = (Dali::Actor *)jarg1;
34336   {
34337     try {
34338       result = ((Dali::Actor const *)arg1)->GetCurrentAnchorPoint();
34339     } catch (std::out_of_range& e) {
34340       {
34341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34342       };
34343     } catch (std::exception& e) {
34344       {
34345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34346       };
34347     } catch (Dali::DaliException e) {
34348       {
34349         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34350       };
34351     } catch (...) {
34352       {
34353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34354       };
34355     }
34356   }
34357
34358   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34359   return jresult;
34360 }
34361
34362
34363 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_0(void * jarg1, float jarg2, float jarg3) {
34364   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34365   float arg2 ;
34366   float arg3 ;
34367
34368   arg1 = (Dali::Actor *)jarg1;
34369   arg2 = (float)jarg2;
34370   arg3 = (float)jarg3;
34371   {
34372     try {
34373       (arg1)->SetSize(arg2,arg3);
34374     } catch (std::out_of_range& e) {
34375       {
34376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34377       };
34378     } catch (std::exception& e) {
34379       {
34380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34381       };
34382     } catch (Dali::DaliException e) {
34383       {
34384         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34385       };
34386     } catch (...) {
34387       {
34388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34389       };
34390     }
34391   }
34392
34393 }
34394
34395
34396 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
34397   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34398   float arg2 ;
34399   float arg3 ;
34400   float arg4 ;
34401
34402   arg1 = (Dali::Actor *)jarg1;
34403   arg2 = (float)jarg2;
34404   arg3 = (float)jarg3;
34405   arg4 = (float)jarg4;
34406   {
34407     try {
34408       (arg1)->SetSize(arg2,arg3,arg4);
34409     } catch (std::out_of_range& e) {
34410       {
34411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34412       };
34413     } catch (std::exception& e) {
34414       {
34415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34416       };
34417     } catch (Dali::DaliException e) {
34418       {
34419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34420       };
34421     } catch (...) {
34422       {
34423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34424       };
34425     }
34426   }
34427
34428 }
34429
34430
34431 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_2(void * jarg1, void * jarg2) {
34432   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34433   Dali::Vector2 *arg2 = 0 ;
34434
34435   arg1 = (Dali::Actor *)jarg1;
34436   arg2 = (Dali::Vector2 *)jarg2;
34437   if (!arg2) {
34438     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
34439     return ;
34440   }
34441   {
34442     try {
34443       (arg1)->SetSize((Dali::Vector2 const &)*arg2);
34444     } catch (std::out_of_range& e) {
34445       {
34446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34447       };
34448     } catch (std::exception& e) {
34449       {
34450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34451       };
34452     } catch (Dali::DaliException e) {
34453       {
34454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34455       };
34456     } catch (...) {
34457       {
34458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34459       };
34460     }
34461   }
34462
34463 }
34464
34465
34466 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_3(void * jarg1, void * jarg2) {
34467   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34468   Dali::Vector3 *arg2 = 0 ;
34469
34470   arg1 = (Dali::Actor *)jarg1;
34471   arg2 = (Dali::Vector3 *)jarg2;
34472   if (!arg2) {
34473     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34474     return ;
34475   }
34476   {
34477     try {
34478       (arg1)->SetSize((Dali::Vector3 const &)*arg2);
34479     } catch (std::out_of_range& e) {
34480       {
34481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34482       };
34483     } catch (std::exception& e) {
34484       {
34485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34486       };
34487     } catch (Dali::DaliException e) {
34488       {
34489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34490       };
34491     } catch (...) {
34492       {
34493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34494       };
34495     }
34496   }
34497
34498 }
34499
34500
34501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetTargetSize(void * jarg1) {
34502   void * jresult ;
34503   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34504   Dali::Vector3 result;
34505
34506   arg1 = (Dali::Actor *)jarg1;
34507   {
34508     try {
34509       result = ((Dali::Actor const *)arg1)->GetTargetSize();
34510     } catch (std::out_of_range& e) {
34511       {
34512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34513       };
34514     } catch (std::exception& e) {
34515       {
34516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34517       };
34518     } catch (Dali::DaliException e) {
34519       {
34520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34521       };
34522     } catch (...) {
34523       {
34524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34525       };
34526     }
34527   }
34528
34529   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34530   return jresult;
34531 }
34532
34533
34534 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentSize(void * jarg1) {
34535   void * jresult ;
34536   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34537   Dali::Vector3 result;
34538
34539   arg1 = (Dali::Actor *)jarg1;
34540   {
34541     try {
34542       result = ((Dali::Actor const *)arg1)->GetCurrentSize();
34543     } catch (std::out_of_range& e) {
34544       {
34545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34546       };
34547     } catch (std::exception& e) {
34548       {
34549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34550       };
34551     } catch (Dali::DaliException e) {
34552       {
34553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34554       };
34555     } catch (...) {
34556       {
34557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34558       };
34559     }
34560   }
34561
34562   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34563   return jresult;
34564 }
34565
34566
34567 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetNaturalSize(void * jarg1) {
34568   void * jresult ;
34569   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34570   Dali::Vector3 result;
34571
34572   arg1 = (Dali::Actor *)jarg1;
34573   {
34574     try {
34575       result = ((Dali::Actor const *)arg1)->GetNaturalSize();
34576     } catch (std::out_of_range& e) {
34577       {
34578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34579       };
34580     } catch (std::exception& e) {
34581       {
34582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34583       };
34584     } catch (Dali::DaliException e) {
34585       {
34586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34587       };
34588     } catch (...) {
34589       {
34590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34591       };
34592     }
34593   }
34594
34595   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34596   return jresult;
34597 }
34598
34599
34600 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_0(void * jarg1, float jarg2, float jarg3) {
34601   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34602   float arg2 ;
34603   float arg3 ;
34604
34605   arg1 = (Dali::Actor *)jarg1;
34606   arg2 = (float)jarg2;
34607   arg3 = (float)jarg3;
34608   {
34609     try {
34610       (arg1)->SetPosition(arg2,arg3);
34611     } catch (std::out_of_range& e) {
34612       {
34613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34614       };
34615     } catch (std::exception& e) {
34616       {
34617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34618       };
34619     } catch (Dali::DaliException e) {
34620       {
34621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34622       };
34623     } catch (...) {
34624       {
34625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34626       };
34627     }
34628   }
34629
34630 }
34631
34632
34633 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
34634   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34635   float arg2 ;
34636   float arg3 ;
34637   float arg4 ;
34638
34639   arg1 = (Dali::Actor *)jarg1;
34640   arg2 = (float)jarg2;
34641   arg3 = (float)jarg3;
34642   arg4 = (float)jarg4;
34643   {
34644     try {
34645       (arg1)->SetPosition(arg2,arg3,arg4);
34646     } catch (std::out_of_range& e) {
34647       {
34648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34649       };
34650     } catch (std::exception& e) {
34651       {
34652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34653       };
34654     } catch (Dali::DaliException e) {
34655       {
34656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34657       };
34658     } catch (...) {
34659       {
34660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34661       };
34662     }
34663   }
34664
34665 }
34666
34667
34668 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_2(void * jarg1, void * jarg2) {
34669   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34670   Dali::Vector3 *arg2 = 0 ;
34671
34672   arg1 = (Dali::Actor *)jarg1;
34673   arg2 = (Dali::Vector3 *)jarg2;
34674   if (!arg2) {
34675     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34676     return ;
34677   }
34678   {
34679     try {
34680       (arg1)->SetPosition((Dali::Vector3 const &)*arg2);
34681     } catch (std::out_of_range& e) {
34682       {
34683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34684       };
34685     } catch (std::exception& e) {
34686       {
34687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34688       };
34689     } catch (Dali::DaliException e) {
34690       {
34691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34692       };
34693     } catch (...) {
34694       {
34695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34696       };
34697     }
34698   }
34699
34700 }
34701
34702
34703 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetX(void * jarg1, float jarg2) {
34704   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34705   float arg2 ;
34706
34707   arg1 = (Dali::Actor *)jarg1;
34708   arg2 = (float)jarg2;
34709   {
34710     try {
34711       (arg1)->SetX(arg2);
34712     } catch (std::out_of_range& e) {
34713       {
34714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34715       };
34716     } catch (std::exception& e) {
34717       {
34718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34719       };
34720     } catch (Dali::DaliException e) {
34721       {
34722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34723       };
34724     } catch (...) {
34725       {
34726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34727       };
34728     }
34729   }
34730
34731 }
34732
34733
34734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetY(void * jarg1, float jarg2) {
34735   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34736   float arg2 ;
34737
34738   arg1 = (Dali::Actor *)jarg1;
34739   arg2 = (float)jarg2;
34740   {
34741     try {
34742       (arg1)->SetY(arg2);
34743     } catch (std::out_of_range& e) {
34744       {
34745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34746       };
34747     } catch (std::exception& e) {
34748       {
34749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34750       };
34751     } catch (Dali::DaliException e) {
34752       {
34753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34754       };
34755     } catch (...) {
34756       {
34757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34758       };
34759     }
34760   }
34761
34762 }
34763
34764
34765 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetZ(void * jarg1, float jarg2) {
34766   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34767   float arg2 ;
34768
34769   arg1 = (Dali::Actor *)jarg1;
34770   arg2 = (float)jarg2;
34771   {
34772     try {
34773       (arg1)->SetZ(arg2);
34774     } catch (std::out_of_range& e) {
34775       {
34776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34777       };
34778     } catch (std::exception& e) {
34779       {
34780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34781       };
34782     } catch (Dali::DaliException e) {
34783       {
34784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34785       };
34786     } catch (...) {
34787       {
34788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34789       };
34790     }
34791   }
34792
34793 }
34794
34795
34796 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_TranslateBy(void * jarg1, void * jarg2) {
34797   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34798   Dali::Vector3 *arg2 = 0 ;
34799
34800   arg1 = (Dali::Actor *)jarg1;
34801   arg2 = (Dali::Vector3 *)jarg2;
34802   if (!arg2) {
34803     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34804     return ;
34805   }
34806   {
34807     try {
34808       (arg1)->TranslateBy((Dali::Vector3 const &)*arg2);
34809     } catch (std::out_of_range& e) {
34810       {
34811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34812       };
34813     } catch (std::exception& e) {
34814       {
34815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34816       };
34817     } catch (Dali::DaliException e) {
34818       {
34819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34820       };
34821     } catch (...) {
34822       {
34823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34824       };
34825     }
34826   }
34827
34828 }
34829
34830
34831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentPosition(void * jarg1) {
34832   void * jresult ;
34833   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34834   Dali::Vector3 result;
34835
34836   arg1 = (Dali::Actor *)jarg1;
34837   {
34838     try {
34839       result = ((Dali::Actor const *)arg1)->GetCurrentPosition();
34840     } catch (std::out_of_range& e) {
34841       {
34842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34843       };
34844     } catch (std::exception& e) {
34845       {
34846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34847       };
34848     } catch (Dali::DaliException e) {
34849       {
34850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34851       };
34852     } catch (...) {
34853       {
34854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34855       };
34856     }
34857   }
34858
34859   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34860   return jresult;
34861 }
34862
34863
34864 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldPosition(void * jarg1) {
34865   void * jresult ;
34866   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34867   Dali::Vector3 result;
34868
34869   arg1 = (Dali::Actor *)jarg1;
34870   {
34871     try {
34872       result = ((Dali::Actor const *)arg1)->GetCurrentWorldPosition();
34873     } catch (std::out_of_range& e) {
34874       {
34875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34876       };
34877     } catch (std::exception& e) {
34878       {
34879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34880       };
34881     } catch (Dali::DaliException e) {
34882       {
34883         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34884       };
34885     } catch (...) {
34886       {
34887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34888       };
34889     }
34890   }
34891
34892   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34893   return jresult;
34894 }
34895
34896
34897 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritPosition(void * jarg1, unsigned int jarg2) {
34898   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34899   bool arg2 ;
34900
34901   arg1 = (Dali::Actor *)jarg1;
34902   arg2 = jarg2 ? true : false;
34903   {
34904     try {
34905       (arg1)->SetInheritPosition(arg2);
34906     } catch (std::out_of_range& e) {
34907       {
34908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34909       };
34910     } catch (std::exception& e) {
34911       {
34912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34913       };
34914     } catch (Dali::DaliException e) {
34915       {
34916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34917       };
34918     } catch (...) {
34919       {
34920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34921       };
34922     }
34923   }
34924
34925 }
34926
34927
34928 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetPositionInheritanceMode(void * jarg1) {
34929   int jresult ;
34930   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34931   Dali::PositionInheritanceMode result;
34932
34933   arg1 = (Dali::Actor *)jarg1;
34934   {
34935     try {
34936       result = (Dali::PositionInheritanceMode)((Dali::Actor const *)arg1)->GetPositionInheritanceMode();
34937     } catch (std::out_of_range& e) {
34938       {
34939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34940       };
34941     } catch (std::exception& e) {
34942       {
34943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34944       };
34945     } catch (Dali::DaliException e) {
34946       {
34947         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34948       };
34949     } catch (...) {
34950       {
34951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34952       };
34953     }
34954   }
34955
34956   jresult = (int)result;
34957   return jresult;
34958 }
34959
34960
34961 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsPositionInherited(void * jarg1) {
34962   unsigned int jresult ;
34963   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34964   bool result;
34965
34966   arg1 = (Dali::Actor *)jarg1;
34967   {
34968     try {
34969       result = (bool)((Dali::Actor const *)arg1)->IsPositionInherited();
34970     } catch (std::out_of_range& e) {
34971       {
34972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34973       };
34974     } catch (std::exception& e) {
34975       {
34976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34977       };
34978     } catch (Dali::DaliException e) {
34979       {
34980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34981       };
34982     } catch (...) {
34983       {
34984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34985       };
34986     }
34987   }
34988
34989   jresult = result;
34990   return jresult;
34991 }
34992
34993
34994 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
34995   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34996   Dali::Degree *arg2 = 0 ;
34997   Dali::Vector3 *arg3 = 0 ;
34998
34999   arg1 = (Dali::Actor *)jarg1;
35000   arg2 = (Dali::Degree *)jarg2;
35001   if (!arg2) {
35002     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
35003     return ;
35004   }
35005   arg3 = (Dali::Vector3 *)jarg3;
35006   if (!arg3) {
35007     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35008     return ;
35009   }
35010   {
35011     try {
35012       (arg1)->SetOrientation((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
35013     } catch (std::out_of_range& e) {
35014       {
35015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35016       };
35017     } catch (std::exception& e) {
35018       {
35019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35020       };
35021     } catch (Dali::DaliException e) {
35022       {
35023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35024       };
35025     } catch (...) {
35026       {
35027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35028       };
35029     }
35030   }
35031
35032 }
35033
35034
35035 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
35036   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35037   Dali::Radian *arg2 = 0 ;
35038   Dali::Vector3 *arg3 = 0 ;
35039
35040   arg1 = (Dali::Actor *)jarg1;
35041   arg2 = (Dali::Radian *)jarg2;
35042   if (!arg2) {
35043     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
35044     return ;
35045   }
35046   arg3 = (Dali::Vector3 *)jarg3;
35047   if (!arg3) {
35048     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35049     return ;
35050   }
35051   {
35052     try {
35053       (arg1)->SetOrientation((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
35054     } catch (std::out_of_range& e) {
35055       {
35056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35057       };
35058     } catch (std::exception& e) {
35059       {
35060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35061       };
35062     } catch (Dali::DaliException e) {
35063       {
35064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35065       };
35066     } catch (...) {
35067       {
35068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35069       };
35070     }
35071   }
35072
35073 }
35074
35075
35076 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_2(void * jarg1, void * jarg2) {
35077   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35078   Dali::Quaternion *arg2 = 0 ;
35079
35080   arg1 = (Dali::Actor *)jarg1;
35081   arg2 = (Dali::Quaternion *)jarg2;
35082   if (!arg2) {
35083     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
35084     return ;
35085   }
35086   {
35087     try {
35088       (arg1)->SetOrientation((Dali::Quaternion const &)*arg2);
35089     } catch (std::out_of_range& e) {
35090       {
35091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35092       };
35093     } catch (std::exception& e) {
35094       {
35095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35096       };
35097     } catch (Dali::DaliException e) {
35098       {
35099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35100       };
35101     } catch (...) {
35102       {
35103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35104       };
35105     }
35106   }
35107
35108 }
35109
35110
35111 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
35112   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35113   Dali::Degree *arg2 = 0 ;
35114   Dali::Vector3 *arg3 = 0 ;
35115
35116   arg1 = (Dali::Actor *)jarg1;
35117   arg2 = (Dali::Degree *)jarg2;
35118   if (!arg2) {
35119     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
35120     return ;
35121   }
35122   arg3 = (Dali::Vector3 *)jarg3;
35123   if (!arg3) {
35124     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35125     return ;
35126   }
35127   {
35128     try {
35129       (arg1)->RotateBy((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
35130     } catch (std::out_of_range& e) {
35131       {
35132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35133       };
35134     } catch (std::exception& e) {
35135       {
35136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35137       };
35138     } catch (Dali::DaliException e) {
35139       {
35140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35141       };
35142     } catch (...) {
35143       {
35144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35145       };
35146     }
35147   }
35148
35149 }
35150
35151
35152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
35153   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35154   Dali::Radian *arg2 = 0 ;
35155   Dali::Vector3 *arg3 = 0 ;
35156
35157   arg1 = (Dali::Actor *)jarg1;
35158   arg2 = (Dali::Radian *)jarg2;
35159   if (!arg2) {
35160     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
35161     return ;
35162   }
35163   arg3 = (Dali::Vector3 *)jarg3;
35164   if (!arg3) {
35165     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35166     return ;
35167   }
35168   {
35169     try {
35170       (arg1)->RotateBy((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
35171     } catch (std::out_of_range& e) {
35172       {
35173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35174       };
35175     } catch (std::exception& e) {
35176       {
35177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35178       };
35179     } catch (Dali::DaliException e) {
35180       {
35181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35182       };
35183     } catch (...) {
35184       {
35185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35186       };
35187     }
35188   }
35189
35190 }
35191
35192
35193 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_2(void * jarg1, void * jarg2) {
35194   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35195   Dali::Quaternion *arg2 = 0 ;
35196
35197   arg1 = (Dali::Actor *)jarg1;
35198   arg2 = (Dali::Quaternion *)jarg2;
35199   if (!arg2) {
35200     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
35201     return ;
35202   }
35203   {
35204     try {
35205       (arg1)->RotateBy((Dali::Quaternion const &)*arg2);
35206     } catch (std::out_of_range& e) {
35207       {
35208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35209       };
35210     } catch (std::exception& e) {
35211       {
35212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35213       };
35214     } catch (Dali::DaliException e) {
35215       {
35216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35217       };
35218     } catch (...) {
35219       {
35220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35221       };
35222     }
35223   }
35224
35225 }
35226
35227
35228 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOrientation(void * jarg1) {
35229   void * jresult ;
35230   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35231   Dali::Quaternion result;
35232
35233   arg1 = (Dali::Actor *)jarg1;
35234   {
35235     try {
35236       result = ((Dali::Actor const *)arg1)->GetCurrentOrientation();
35237     } catch (std::out_of_range& e) {
35238       {
35239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35240       };
35241     } catch (std::exception& e) {
35242       {
35243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35244       };
35245     } catch (Dali::DaliException e) {
35246       {
35247         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35248       };
35249     } catch (...) {
35250       {
35251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35252       };
35253     }
35254   }
35255
35256   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
35257   return jresult;
35258 }
35259
35260
35261 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritOrientation(void * jarg1, unsigned int jarg2) {
35262   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35263   bool arg2 ;
35264
35265   arg1 = (Dali::Actor *)jarg1;
35266   arg2 = jarg2 ? true : false;
35267   {
35268     try {
35269       (arg1)->SetInheritOrientation(arg2);
35270     } catch (std::out_of_range& e) {
35271       {
35272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35273       };
35274     } catch (std::exception& e) {
35275       {
35276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35277       };
35278     } catch (Dali::DaliException e) {
35279       {
35280         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35281       };
35282     } catch (...) {
35283       {
35284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35285       };
35286     }
35287   }
35288
35289 }
35290
35291
35292 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsOrientationInherited(void * jarg1) {
35293   unsigned int jresult ;
35294   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35295   bool result;
35296
35297   arg1 = (Dali::Actor *)jarg1;
35298   {
35299     try {
35300       result = (bool)((Dali::Actor const *)arg1)->IsOrientationInherited();
35301     } catch (std::out_of_range& e) {
35302       {
35303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35304       };
35305     } catch (std::exception& e) {
35306       {
35307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35308       };
35309     } catch (Dali::DaliException e) {
35310       {
35311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35312       };
35313     } catch (...) {
35314       {
35315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35316       };
35317     }
35318   }
35319
35320   jresult = result;
35321   return jresult;
35322 }
35323
35324
35325 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldOrientation(void * jarg1) {
35326   void * jresult ;
35327   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35328   Dali::Quaternion result;
35329
35330   arg1 = (Dali::Actor *)jarg1;
35331   {
35332     try {
35333       result = ((Dali::Actor const *)arg1)->GetCurrentWorldOrientation();
35334     } catch (std::out_of_range& e) {
35335       {
35336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35337       };
35338     } catch (std::exception& e) {
35339       {
35340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35341       };
35342     } catch (Dali::DaliException e) {
35343       {
35344         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35345       };
35346     } catch (...) {
35347       {
35348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35349       };
35350     }
35351   }
35352
35353   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
35354   return jresult;
35355 }
35356
35357
35358 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_0(void * jarg1, float jarg2) {
35359   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35360   float arg2 ;
35361
35362   arg1 = (Dali::Actor *)jarg1;
35363   arg2 = (float)jarg2;
35364   {
35365     try {
35366       (arg1)->SetScale(arg2);
35367     } catch (std::out_of_range& e) {
35368       {
35369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35370       };
35371     } catch (std::exception& e) {
35372       {
35373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35374       };
35375     } catch (Dali::DaliException e) {
35376       {
35377         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35378       };
35379     } catch (...) {
35380       {
35381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35382       };
35383     }
35384   }
35385
35386 }
35387
35388
35389 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
35390   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35391   float arg2 ;
35392   float arg3 ;
35393   float arg4 ;
35394
35395   arg1 = (Dali::Actor *)jarg1;
35396   arg2 = (float)jarg2;
35397   arg3 = (float)jarg3;
35398   arg4 = (float)jarg4;
35399   {
35400     try {
35401       (arg1)->SetScale(arg2,arg3,arg4);
35402     } catch (std::out_of_range& e) {
35403       {
35404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35405       };
35406     } catch (std::exception& e) {
35407       {
35408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35409       };
35410     } catch (Dali::DaliException e) {
35411       {
35412         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35413       };
35414     } catch (...) {
35415       {
35416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35417       };
35418     }
35419   }
35420
35421 }
35422
35423
35424 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_2(void * jarg1, void * jarg2) {
35425   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35426   Dali::Vector3 *arg2 = 0 ;
35427
35428   arg1 = (Dali::Actor *)jarg1;
35429   arg2 = (Dali::Vector3 *)jarg2;
35430   if (!arg2) {
35431     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35432     return ;
35433   }
35434   {
35435     try {
35436       (arg1)->SetScale((Dali::Vector3 const &)*arg2);
35437     } catch (std::out_of_range& e) {
35438       {
35439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35440       };
35441     } catch (std::exception& e) {
35442       {
35443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35444       };
35445     } catch (Dali::DaliException e) {
35446       {
35447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35448       };
35449     } catch (...) {
35450       {
35451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35452       };
35453     }
35454   }
35455
35456 }
35457
35458
35459 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_ScaleBy(void * jarg1, void * jarg2) {
35460   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35461   Dali::Vector3 *arg2 = 0 ;
35462
35463   arg1 = (Dali::Actor *)jarg1;
35464   arg2 = (Dali::Vector3 *)jarg2;
35465   if (!arg2) {
35466     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35467     return ;
35468   }
35469   {
35470     try {
35471       (arg1)->ScaleBy((Dali::Vector3 const &)*arg2);
35472     } catch (std::out_of_range& e) {
35473       {
35474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35475       };
35476     } catch (std::exception& e) {
35477       {
35478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35479       };
35480     } catch (Dali::DaliException e) {
35481       {
35482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35483       };
35484     } catch (...) {
35485       {
35486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35487       };
35488     }
35489   }
35490
35491 }
35492
35493
35494 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentScale(void * jarg1) {
35495   void * jresult ;
35496   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35497   Dali::Vector3 result;
35498
35499   arg1 = (Dali::Actor *)jarg1;
35500   {
35501     try {
35502       result = ((Dali::Actor const *)arg1)->GetCurrentScale();
35503     } catch (std::out_of_range& e) {
35504       {
35505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35506       };
35507     } catch (std::exception& e) {
35508       {
35509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35510       };
35511     } catch (Dali::DaliException e) {
35512       {
35513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35514       };
35515     } catch (...) {
35516       {
35517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35518       };
35519     }
35520   }
35521
35522   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
35523   return jresult;
35524 }
35525
35526
35527 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldScale(void * jarg1) {
35528   void * jresult ;
35529   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35530   Dali::Vector3 result;
35531
35532   arg1 = (Dali::Actor *)jarg1;
35533   {
35534     try {
35535       result = ((Dali::Actor const *)arg1)->GetCurrentWorldScale();
35536     } catch (std::out_of_range& e) {
35537       {
35538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35539       };
35540     } catch (std::exception& e) {
35541       {
35542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35543       };
35544     } catch (Dali::DaliException e) {
35545       {
35546         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35547       };
35548     } catch (...) {
35549       {
35550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35551       };
35552     }
35553   }
35554
35555   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
35556   return jresult;
35557 }
35558
35559
35560 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritScale(void * jarg1, unsigned int jarg2) {
35561   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35562   bool arg2 ;
35563
35564   arg1 = (Dali::Actor *)jarg1;
35565   arg2 = jarg2 ? true : false;
35566   {
35567     try {
35568       (arg1)->SetInheritScale(arg2);
35569     } catch (std::out_of_range& e) {
35570       {
35571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35572       };
35573     } catch (std::exception& e) {
35574       {
35575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35576       };
35577     } catch (Dali::DaliException e) {
35578       {
35579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35580       };
35581     } catch (...) {
35582       {
35583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35584       };
35585     }
35586   }
35587
35588 }
35589
35590
35591 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsScaleInherited(void * jarg1) {
35592   unsigned int jresult ;
35593   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35594   bool result;
35595
35596   arg1 = (Dali::Actor *)jarg1;
35597   {
35598     try {
35599       result = (bool)((Dali::Actor const *)arg1)->IsScaleInherited();
35600     } catch (std::out_of_range& e) {
35601       {
35602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35603       };
35604     } catch (std::exception& e) {
35605       {
35606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35607       };
35608     } catch (Dali::DaliException e) {
35609       {
35610         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35611       };
35612     } catch (...) {
35613       {
35614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35615       };
35616     }
35617   }
35618
35619   jresult = result;
35620   return jresult;
35621 }
35622
35623
35624 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldMatrix(void * jarg1) {
35625   void * jresult ;
35626   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35627   Dali::Matrix result;
35628
35629   arg1 = (Dali::Actor *)jarg1;
35630   {
35631     try {
35632       result = ((Dali::Actor const *)arg1)->GetCurrentWorldMatrix();
35633     } catch (std::out_of_range& e) {
35634       {
35635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35636       };
35637     } catch (std::exception& e) {
35638       {
35639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35640       };
35641     } catch (Dali::DaliException e) {
35642       {
35643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35644       };
35645     } catch (...) {
35646       {
35647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35648       };
35649     }
35650   }
35651
35652   jresult = new Dali::Matrix((const Dali::Matrix &)result);
35653   return jresult;
35654 }
35655
35656
35657 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetVisible(void * jarg1, unsigned int jarg2) {
35658   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35659   bool arg2 ;
35660
35661   arg1 = (Dali::Actor *)jarg1;
35662   arg2 = jarg2 ? true : false;
35663   {
35664     try {
35665       (arg1)->SetVisible(arg2);
35666     } catch (std::out_of_range& e) {
35667       {
35668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35669       };
35670     } catch (std::exception& e) {
35671       {
35672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35673       };
35674     } catch (Dali::DaliException e) {
35675       {
35676         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35677       };
35678     } catch (...) {
35679       {
35680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35681       };
35682     }
35683   }
35684
35685 }
35686
35687
35688 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsVisible(void * jarg1) {
35689   unsigned int jresult ;
35690   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35691   bool result;
35692
35693   arg1 = (Dali::Actor *)jarg1;
35694   {
35695     try {
35696       result = (bool)((Dali::Actor const *)arg1)->IsVisible();
35697     } catch (std::out_of_range& e) {
35698       {
35699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35700       };
35701     } catch (std::exception& e) {
35702       {
35703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35704       };
35705     } catch (Dali::DaliException e) {
35706       {
35707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35708       };
35709     } catch (...) {
35710       {
35711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35712       };
35713     }
35714   }
35715
35716   jresult = result;
35717   return jresult;
35718 }
35719
35720
35721 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOpacity(void * jarg1, float jarg2) {
35722   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35723   float arg2 ;
35724
35725   arg1 = (Dali::Actor *)jarg1;
35726   arg2 = (float)jarg2;
35727   {
35728     try {
35729       (arg1)->SetOpacity(arg2);
35730     } catch (std::out_of_range& e) {
35731       {
35732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35733       };
35734     } catch (std::exception& e) {
35735       {
35736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35737       };
35738     } catch (Dali::DaliException e) {
35739       {
35740         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35741       };
35742     } catch (...) {
35743       {
35744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35745       };
35746     }
35747   }
35748
35749 }
35750
35751
35752 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOpacity(void * jarg1) {
35753   float jresult ;
35754   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35755   float result;
35756
35757   arg1 = (Dali::Actor *)jarg1;
35758   {
35759     try {
35760       result = (float)((Dali::Actor const *)arg1)->GetCurrentOpacity();
35761     } catch (std::out_of_range& e) {
35762       {
35763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35764       };
35765     } catch (std::exception& e) {
35766       {
35767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35768       };
35769     } catch (Dali::DaliException e) {
35770       {
35771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35772       };
35773     } catch (...) {
35774       {
35775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35776       };
35777     }
35778   }
35779
35780   jresult = result;
35781   return jresult;
35782 }
35783
35784
35785 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColor(void * jarg1, void * jarg2) {
35786   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35787   Dali::Vector4 *arg2 = 0 ;
35788
35789   arg1 = (Dali::Actor *)jarg1;
35790   arg2 = (Dali::Vector4 *)jarg2;
35791   if (!arg2) {
35792     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
35793     return ;
35794   }
35795   {
35796     try {
35797       (arg1)->SetColor((Dali::Vector4 const &)*arg2);
35798     } catch (std::out_of_range& e) {
35799       {
35800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35801       };
35802     } catch (std::exception& e) {
35803       {
35804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35805       };
35806     } catch (Dali::DaliException e) {
35807       {
35808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35809       };
35810     } catch (...) {
35811       {
35812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35813       };
35814     }
35815   }
35816
35817 }
35818
35819
35820 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentColor(void * jarg1) {
35821   void * jresult ;
35822   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35823   Dali::Vector4 result;
35824
35825   arg1 = (Dali::Actor *)jarg1;
35826   {
35827     try {
35828       result = ((Dali::Actor const *)arg1)->GetCurrentColor();
35829     } catch (std::out_of_range& e) {
35830       {
35831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35832       };
35833     } catch (std::exception& e) {
35834       {
35835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35836       };
35837     } catch (Dali::DaliException e) {
35838       {
35839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35840       };
35841     } catch (...) {
35842       {
35843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35844       };
35845     }
35846   }
35847
35848   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
35849   return jresult;
35850 }
35851
35852
35853 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColorMode(void * jarg1, int jarg2) {
35854   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35855   Dali::ColorMode arg2 ;
35856
35857   arg1 = (Dali::Actor *)jarg1;
35858   arg2 = (Dali::ColorMode)jarg2;
35859   {
35860     try {
35861       (arg1)->SetColorMode(arg2);
35862     } catch (std::out_of_range& e) {
35863       {
35864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35865       };
35866     } catch (std::exception& e) {
35867       {
35868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35869       };
35870     } catch (Dali::DaliException e) {
35871       {
35872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35873       };
35874     } catch (...) {
35875       {
35876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35877       };
35878     }
35879   }
35880
35881 }
35882
35883
35884 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetColorMode(void * jarg1) {
35885   int jresult ;
35886   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35887   Dali::ColorMode result;
35888
35889   arg1 = (Dali::Actor *)jarg1;
35890   {
35891     try {
35892       result = (Dali::ColorMode)((Dali::Actor const *)arg1)->GetColorMode();
35893     } catch (std::out_of_range& e) {
35894       {
35895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35896       };
35897     } catch (std::exception& e) {
35898       {
35899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35900       };
35901     } catch (Dali::DaliException e) {
35902       {
35903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35904       };
35905     } catch (...) {
35906       {
35907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35908       };
35909     }
35910   }
35911
35912   jresult = (int)result;
35913   return jresult;
35914 }
35915
35916
35917 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldColor(void * jarg1) {
35918   void * jresult ;
35919   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35920   Dali::Vector4 result;
35921
35922   arg1 = (Dali::Actor *)jarg1;
35923   {
35924     try {
35925       result = ((Dali::Actor const *)arg1)->GetCurrentWorldColor();
35926     } catch (std::out_of_range& e) {
35927       {
35928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35929       };
35930     } catch (std::exception& e) {
35931       {
35932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35933       };
35934     } catch (Dali::DaliException e) {
35935       {
35936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35937       };
35938     } catch (...) {
35939       {
35940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35941       };
35942     }
35943   }
35944
35945   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
35946   return jresult;
35947 }
35948
35949
35950 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetDrawMode(void * jarg1, int jarg2) {
35951   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35952   Dali::DrawMode::Type arg2 ;
35953
35954   arg1 = (Dali::Actor *)jarg1;
35955   arg2 = (Dali::DrawMode::Type)jarg2;
35956   {
35957     try {
35958       (arg1)->SetDrawMode(arg2);
35959     } catch (std::out_of_range& e) {
35960       {
35961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35962       };
35963     } catch (std::exception& e) {
35964       {
35965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35966       };
35967     } catch (Dali::DaliException e) {
35968       {
35969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35970       };
35971     } catch (...) {
35972       {
35973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35974       };
35975     }
35976   }
35977
35978 }
35979
35980
35981 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetDrawMode(void * jarg1) {
35982   int jresult ;
35983   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35984   Dali::DrawMode::Type result;
35985
35986   arg1 = (Dali::Actor *)jarg1;
35987   {
35988     try {
35989       result = (Dali::DrawMode::Type)((Dali::Actor const *)arg1)->GetDrawMode();
35990     } catch (std::out_of_range& e) {
35991       {
35992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35993       };
35994     } catch (std::exception& e) {
35995       {
35996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35997       };
35998     } catch (Dali::DaliException e) {
35999       {
36000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36001       };
36002     } catch (...) {
36003       {
36004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36005       };
36006     }
36007   }
36008
36009   jresult = (int)result;
36010   return jresult;
36011 }
36012
36013
36014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSensitive(void * jarg1, unsigned int jarg2) {
36015   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36016   bool arg2 ;
36017
36018   arg1 = (Dali::Actor *)jarg1;
36019   arg2 = jarg2 ? true : false;
36020   {
36021     try {
36022       (arg1)->SetSensitive(arg2);
36023     } catch (std::out_of_range& e) {
36024       {
36025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36026       };
36027     } catch (std::exception& e) {
36028       {
36029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36030       };
36031     } catch (Dali::DaliException e) {
36032       {
36033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36034       };
36035     } catch (...) {
36036       {
36037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36038       };
36039     }
36040   }
36041
36042 }
36043
36044
36045 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsSensitive(void * jarg1) {
36046   unsigned int jresult ;
36047   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36048   bool result;
36049
36050   arg1 = (Dali::Actor *)jarg1;
36051   {
36052     try {
36053       result = (bool)((Dali::Actor const *)arg1)->IsSensitive();
36054     } catch (std::out_of_range& e) {
36055       {
36056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36057       };
36058     } catch (std::exception& e) {
36059       {
36060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36061       };
36062     } catch (Dali::DaliException e) {
36063       {
36064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36065       };
36066     } catch (...) {
36067       {
36068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36069       };
36070     }
36071   }
36072
36073   jresult = result;
36074   return jresult;
36075 }
36076
36077
36078 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_ScreenToLocal(void * jarg1, float * jarg2, float * jarg3, float jarg4, float jarg5) {
36079   unsigned int jresult ;
36080   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36081   float *arg2 = 0 ;
36082   float *arg3 = 0 ;
36083   float arg4 ;
36084   float arg5 ;
36085   bool result;
36086
36087   arg1 = (Dali::Actor *)jarg1;
36088   arg2 = (float *)jarg2;
36089   arg3 = (float *)jarg3;
36090   arg4 = (float)jarg4;
36091   arg5 = (float)jarg5;
36092   {
36093     try {
36094       result = (bool)((Dali::Actor const *)arg1)->ScreenToLocal(*arg2,*arg3,arg4,arg5);
36095     } catch (std::out_of_range& e) {
36096       {
36097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36098       };
36099     } catch (std::exception& e) {
36100       {
36101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36102       };
36103     } catch (Dali::DaliException e) {
36104       {
36105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36106       };
36107     } catch (...) {
36108       {
36109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36110       };
36111     }
36112   }
36113
36114   jresult = result;
36115   return jresult;
36116 }
36117
36118
36119 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetLeaveRequired(void * jarg1, unsigned int jarg2) {
36120   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36121   bool arg2 ;
36122
36123   arg1 = (Dali::Actor *)jarg1;
36124   arg2 = jarg2 ? true : false;
36125   {
36126     try {
36127       (arg1)->SetLeaveRequired(arg2);
36128     } catch (std::out_of_range& e) {
36129       {
36130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36131       };
36132     } catch (std::exception& e) {
36133       {
36134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36135       };
36136     } catch (Dali::DaliException e) {
36137       {
36138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36139       };
36140     } catch (...) {
36141       {
36142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36143       };
36144     }
36145   }
36146
36147 }
36148
36149
36150 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetLeaveRequired(void * jarg1) {
36151   unsigned int jresult ;
36152   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36153   bool result;
36154
36155   arg1 = (Dali::Actor *)jarg1;
36156   {
36157     try {
36158       result = (bool)((Dali::Actor const *)arg1)->GetLeaveRequired();
36159     } catch (std::out_of_range& e) {
36160       {
36161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36162       };
36163     } catch (std::exception& e) {
36164       {
36165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36166       };
36167     } catch (Dali::DaliException e) {
36168       {
36169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36170       };
36171     } catch (...) {
36172       {
36173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36174       };
36175     }
36176   }
36177
36178   jresult = result;
36179   return jresult;
36180 }
36181
36182
36183 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetKeyboardFocusable(void * jarg1, unsigned int jarg2) {
36184   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36185   bool arg2 ;
36186
36187   arg1 = (Dali::Actor *)jarg1;
36188   arg2 = jarg2 ? true : false;
36189   {
36190     try {
36191       (arg1)->SetKeyboardFocusable(arg2);
36192     } catch (std::out_of_range& e) {
36193       {
36194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36195       };
36196     } catch (std::exception& e) {
36197       {
36198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36199       };
36200     } catch (Dali::DaliException e) {
36201       {
36202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36203       };
36204     } catch (...) {
36205       {
36206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36207       };
36208     }
36209   }
36210
36211 }
36212
36213
36214 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsKeyboardFocusable(void * jarg1) {
36215   unsigned int jresult ;
36216   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36217   bool result;
36218
36219   arg1 = (Dali::Actor *)jarg1;
36220   {
36221     try {
36222       result = (bool)((Dali::Actor const *)arg1)->IsKeyboardFocusable();
36223     } catch (std::out_of_range& e) {
36224       {
36225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36226       };
36227     } catch (std::exception& e) {
36228       {
36229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36230       };
36231     } catch (Dali::DaliException e) {
36232       {
36233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36234       };
36235     } catch (...) {
36236       {
36237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36238       };
36239     }
36240   }
36241
36242   jresult = result;
36243   return jresult;
36244 }
36245
36246
36247 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetResizePolicy(void * jarg1, int jarg2, int jarg3) {
36248   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36249   Dali::ResizePolicy::Type arg2 ;
36250   Dali::Dimension::Type arg3 ;
36251
36252   arg1 = (Dali::Actor *)jarg1;
36253   arg2 = (Dali::ResizePolicy::Type)jarg2;
36254   arg3 = (Dali::Dimension::Type)jarg3;
36255   {
36256     try {
36257       (arg1)->SetResizePolicy(arg2,arg3);
36258     } catch (std::out_of_range& e) {
36259       {
36260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36261       };
36262     } catch (std::exception& e) {
36263       {
36264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36265       };
36266     } catch (Dali::DaliException e) {
36267       {
36268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36269       };
36270     } catch (...) {
36271       {
36272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36273       };
36274     }
36275   }
36276
36277 }
36278
36279
36280 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetResizePolicy(void * jarg1, int jarg2) {
36281   int jresult ;
36282   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36283   Dali::Dimension::Type arg2 ;
36284   Dali::ResizePolicy::Type result;
36285
36286   arg1 = (Dali::Actor *)jarg1;
36287   arg2 = (Dali::Dimension::Type)jarg2;
36288   {
36289     try {
36290       result = (Dali::ResizePolicy::Type)((Dali::Actor const *)arg1)->GetResizePolicy(arg2);
36291     } catch (std::out_of_range& e) {
36292       {
36293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36294       };
36295     } catch (std::exception& e) {
36296       {
36297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36298       };
36299     } catch (Dali::DaliException e) {
36300       {
36301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36302       };
36303     } catch (...) {
36304       {
36305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36306       };
36307     }
36308   }
36309
36310   jresult = (int)result;
36311   return jresult;
36312 }
36313
36314
36315 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeScalePolicy(void * jarg1, int jarg2) {
36316   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36317   Dali::SizeScalePolicy::Type arg2 ;
36318
36319   arg1 = (Dali::Actor *)jarg1;
36320   arg2 = (Dali::SizeScalePolicy::Type)jarg2;
36321   {
36322     try {
36323       (arg1)->SetSizeScalePolicy(arg2);
36324     } catch (std::out_of_range& e) {
36325       {
36326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36327       };
36328     } catch (std::exception& e) {
36329       {
36330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36331       };
36332     } catch (Dali::DaliException e) {
36333       {
36334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36335       };
36336     } catch (...) {
36337       {
36338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36339       };
36340     }
36341   }
36342
36343 }
36344
36345
36346 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetSizeScalePolicy(void * jarg1) {
36347   int jresult ;
36348   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36349   Dali::SizeScalePolicy::Type result;
36350
36351   arg1 = (Dali::Actor *)jarg1;
36352   {
36353     try {
36354       result = (Dali::SizeScalePolicy::Type)((Dali::Actor const *)arg1)->GetSizeScalePolicy();
36355     } catch (std::out_of_range& e) {
36356       {
36357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36358       };
36359     } catch (std::exception& e) {
36360       {
36361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36362       };
36363     } catch (Dali::DaliException e) {
36364       {
36365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36366       };
36367     } catch (...) {
36368       {
36369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36370       };
36371     }
36372   }
36373
36374   jresult = (int)result;
36375   return jresult;
36376 }
36377
36378
36379 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeModeFactor(void * jarg1, void * jarg2) {
36380   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36381   Dali::Vector3 *arg2 = 0 ;
36382
36383   arg1 = (Dali::Actor *)jarg1;
36384   arg2 = (Dali::Vector3 *)jarg2;
36385   if (!arg2) {
36386     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
36387     return ;
36388   }
36389   {
36390     try {
36391       (arg1)->SetSizeModeFactor((Dali::Vector3 const &)*arg2);
36392     } catch (std::out_of_range& e) {
36393       {
36394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36395       };
36396     } catch (std::exception& e) {
36397       {
36398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36399       };
36400     } catch (Dali::DaliException e) {
36401       {
36402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36403       };
36404     } catch (...) {
36405       {
36406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36407       };
36408     }
36409   }
36410
36411 }
36412
36413
36414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetSizeModeFactor(void * jarg1) {
36415   void * jresult ;
36416   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36417   Dali::Vector3 result;
36418
36419   arg1 = (Dali::Actor *)jarg1;
36420   {
36421     try {
36422       result = ((Dali::Actor const *)arg1)->GetSizeModeFactor();
36423     } catch (std::out_of_range& e) {
36424       {
36425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36426       };
36427     } catch (std::exception& e) {
36428       {
36429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36430       };
36431     } catch (Dali::DaliException e) {
36432       {
36433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36434       };
36435     } catch (...) {
36436       {
36437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36438       };
36439     }
36440   }
36441
36442   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
36443   return jresult;
36444 }
36445
36446
36447 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetHeightForWidth(void * jarg1, float jarg2) {
36448   float jresult ;
36449   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36450   float arg2 ;
36451   float result;
36452
36453   arg1 = (Dali::Actor *)jarg1;
36454   arg2 = (float)jarg2;
36455   {
36456     try {
36457       result = (float)(arg1)->GetHeightForWidth(arg2);
36458     } catch (std::out_of_range& e) {
36459       {
36460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36461       };
36462     } catch (std::exception& e) {
36463       {
36464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36465       };
36466     } catch (Dali::DaliException e) {
36467       {
36468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36469       };
36470     } catch (...) {
36471       {
36472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36473       };
36474     }
36475   }
36476
36477   jresult = result;
36478   return jresult;
36479 }
36480
36481
36482 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetWidthForHeight(void * jarg1, float jarg2) {
36483   float jresult ;
36484   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36485   float arg2 ;
36486   float result;
36487
36488   arg1 = (Dali::Actor *)jarg1;
36489   arg2 = (float)jarg2;
36490   {
36491     try {
36492       result = (float)(arg1)->GetWidthForHeight(arg2);
36493     } catch (std::out_of_range& e) {
36494       {
36495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36496       };
36497     } catch (std::exception& e) {
36498       {
36499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36500       };
36501     } catch (Dali::DaliException e) {
36502       {
36503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36504       };
36505     } catch (...) {
36506       {
36507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36508       };
36509     }
36510   }
36511
36512   jresult = result;
36513   return jresult;
36514 }
36515
36516
36517 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetRelayoutSize(void * jarg1, int jarg2) {
36518   float jresult ;
36519   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36520   Dali::Dimension::Type arg2 ;
36521   float result;
36522
36523   arg1 = (Dali::Actor *)jarg1;
36524   arg2 = (Dali::Dimension::Type)jarg2;
36525   {
36526     try {
36527       result = (float)((Dali::Actor const *)arg1)->GetRelayoutSize(arg2);
36528     } catch (std::out_of_range& e) {
36529       {
36530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36531       };
36532     } catch (std::exception& e) {
36533       {
36534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36535       };
36536     } catch (Dali::DaliException e) {
36537       {
36538         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36539       };
36540     } catch (...) {
36541       {
36542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36543       };
36544     }
36545   }
36546
36547   jresult = result;
36548   return jresult;
36549 }
36550
36551
36552 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPadding(void * jarg1, void * jarg2) {
36553   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36554   Dali::Padding *arg2 = 0 ;
36555
36556   arg1 = (Dali::Actor *)jarg1;
36557   arg2 = (Dali::Padding *)jarg2;
36558   if (!arg2) {
36559     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding const & type is null", 0);
36560     return ;
36561   }
36562   {
36563     try {
36564       (arg1)->SetPadding((Dali::Padding const &)*arg2);
36565     } catch (std::out_of_range& e) {
36566       {
36567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36568       };
36569     } catch (std::exception& e) {
36570       {
36571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36572       };
36573     } catch (Dali::DaliException e) {
36574       {
36575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36576       };
36577     } catch (...) {
36578       {
36579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36580       };
36581     }
36582   }
36583
36584 }
36585
36586
36587 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_GetPadding(void * jarg1, void * jarg2) {
36588   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36589   Dali::Padding *arg2 = 0 ;
36590
36591   arg1 = (Dali::Actor *)jarg1;
36592   arg2 = (Dali::Padding *)jarg2;
36593   if (!arg2) {
36594     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding & type is null", 0);
36595     return ;
36596   }
36597   {
36598     try {
36599       ((Dali::Actor const *)arg1)->GetPadding(*arg2);
36600     } catch (std::out_of_range& e) {
36601       {
36602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36603       };
36604     } catch (std::exception& e) {
36605       {
36606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36607       };
36608     } catch (Dali::DaliException e) {
36609       {
36610         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36611       };
36612     } catch (...) {
36613       {
36614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36615       };
36616     }
36617   }
36618
36619 }
36620
36621
36622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMinimumSize(void * jarg1, void * jarg2) {
36623   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36624   Dali::Vector2 *arg2 = 0 ;
36625
36626   arg1 = (Dali::Actor *)jarg1;
36627   arg2 = (Dali::Vector2 *)jarg2;
36628   if (!arg2) {
36629     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
36630     return ;
36631   }
36632   {
36633     try {
36634       (arg1)->SetMinimumSize((Dali::Vector2 const &)*arg2);
36635     } catch (std::out_of_range& e) {
36636       {
36637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36638       };
36639     } catch (std::exception& e) {
36640       {
36641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36642       };
36643     } catch (Dali::DaliException e) {
36644       {
36645         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36646       };
36647     } catch (...) {
36648       {
36649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36650       };
36651     }
36652   }
36653
36654 }
36655
36656
36657 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMinimumSize(void * jarg1) {
36658   void * jresult ;
36659   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36660   Dali::Vector2 result;
36661
36662   arg1 = (Dali::Actor *)jarg1;
36663   {
36664     try {
36665       result = (arg1)->GetMinimumSize();
36666     } catch (std::out_of_range& e) {
36667       {
36668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36669       };
36670     } catch (std::exception& e) {
36671       {
36672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36673       };
36674     } catch (Dali::DaliException e) {
36675       {
36676         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36677       };
36678     } catch (...) {
36679       {
36680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36681       };
36682     }
36683   }
36684
36685   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
36686   return jresult;
36687 }
36688
36689
36690 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMaximumSize(void * jarg1, void * jarg2) {
36691   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36692   Dali::Vector2 *arg2 = 0 ;
36693
36694   arg1 = (Dali::Actor *)jarg1;
36695   arg2 = (Dali::Vector2 *)jarg2;
36696   if (!arg2) {
36697     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
36698     return ;
36699   }
36700   {
36701     try {
36702       (arg1)->SetMaximumSize((Dali::Vector2 const &)*arg2);
36703     } catch (std::out_of_range& e) {
36704       {
36705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36706       };
36707     } catch (std::exception& e) {
36708       {
36709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36710       };
36711     } catch (Dali::DaliException e) {
36712       {
36713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36714       };
36715     } catch (...) {
36716       {
36717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36718       };
36719     }
36720   }
36721
36722 }
36723
36724
36725 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMaximumSize(void * jarg1) {
36726   void * jresult ;
36727   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36728   Dali::Vector2 result;
36729
36730   arg1 = (Dali::Actor *)jarg1;
36731   {
36732     try {
36733       result = (arg1)->GetMaximumSize();
36734     } catch (std::out_of_range& e) {
36735       {
36736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36737       };
36738     } catch (std::exception& e) {
36739       {
36740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36741       };
36742     } catch (Dali::DaliException e) {
36743       {
36744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36745       };
36746     } catch (...) {
36747       {
36748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36749       };
36750     }
36751   }
36752
36753   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
36754   return jresult;
36755 }
36756
36757
36758 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetHierarchyDepth(void * jarg1) {
36759   int jresult ;
36760   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36761   int result;
36762
36763   arg1 = (Dali::Actor *)jarg1;
36764   {
36765     try {
36766       result = (int)(arg1)->GetHierarchyDepth();
36767     } catch (std::out_of_range& e) {
36768       {
36769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36770       };
36771     } catch (std::exception& e) {
36772       {
36773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36774       };
36775     } catch (Dali::DaliException e) {
36776       {
36777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36778       };
36779     } catch (...) {
36780       {
36781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36782       };
36783     }
36784   }
36785
36786   jresult = result;
36787   return jresult;
36788 }
36789
36790
36791 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_AddRenderer(void * jarg1, void * jarg2) {
36792   unsigned int jresult ;
36793   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36794   Dali::Renderer *arg2 = 0 ;
36795   unsigned int result;
36796
36797   arg1 = (Dali::Actor *)jarg1;
36798   arg2 = (Dali::Renderer *)jarg2;
36799   if (!arg2) {
36800     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
36801     return 0;
36802   }
36803   {
36804     try {
36805       result = (unsigned int)(arg1)->AddRenderer(*arg2);
36806     } catch (std::out_of_range& e) {
36807       {
36808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36809       };
36810     } catch (std::exception& e) {
36811       {
36812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36813       };
36814     } catch (Dali::DaliException e) {
36815       {
36816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36817       };
36818     } catch (...) {
36819       {
36820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36821       };
36822     }
36823   }
36824
36825   jresult = result;
36826   return jresult;
36827 }
36828
36829
36830 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetRendererCount(void * jarg1) {
36831   unsigned int jresult ;
36832   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36833   unsigned int result;
36834
36835   arg1 = (Dali::Actor *)jarg1;
36836   {
36837     try {
36838       result = (unsigned int)((Dali::Actor const *)arg1)->GetRendererCount();
36839     } catch (std::out_of_range& e) {
36840       {
36841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36842       };
36843     } catch (std::exception& e) {
36844       {
36845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36846       };
36847     } catch (Dali::DaliException e) {
36848       {
36849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36850       };
36851     } catch (...) {
36852       {
36853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36854       };
36855     }
36856   }
36857
36858   jresult = result;
36859   return jresult;
36860 }
36861
36862
36863 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetRendererAt(void * jarg1, unsigned int jarg2) {
36864   void * jresult ;
36865   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36866   unsigned int arg2 ;
36867   Dali::Renderer result;
36868
36869   arg1 = (Dali::Actor *)jarg1;
36870   arg2 = (unsigned int)jarg2;
36871   {
36872     try {
36873       result = (arg1)->GetRendererAt(arg2);
36874     } catch (std::out_of_range& e) {
36875       {
36876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36877       };
36878     } catch (std::exception& e) {
36879       {
36880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36881       };
36882     } catch (Dali::DaliException e) {
36883       {
36884         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36885       };
36886     } catch (...) {
36887       {
36888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36889       };
36890     }
36891   }
36892
36893   jresult = new Dali::Renderer((const Dali::Renderer &)result);
36894   return jresult;
36895 }
36896
36897
36898 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_0(void * jarg1, void * jarg2) {
36899   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36900   Dali::Renderer *arg2 = 0 ;
36901
36902   arg1 = (Dali::Actor *)jarg1;
36903   arg2 = (Dali::Renderer *)jarg2;
36904   if (!arg2) {
36905     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
36906     return ;
36907   }
36908   {
36909     try {
36910       (arg1)->RemoveRenderer(*arg2);
36911     } catch (std::out_of_range& e) {
36912       {
36913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36914       };
36915     } catch (std::exception& e) {
36916       {
36917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36918       };
36919     } catch (Dali::DaliException e) {
36920       {
36921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36922       };
36923     } catch (...) {
36924       {
36925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36926       };
36927     }
36928   }
36929
36930 }
36931
36932
36933 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_1(void * jarg1, unsigned int jarg2) {
36934   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36935   unsigned int arg2 ;
36936
36937   arg1 = (Dali::Actor *)jarg1;
36938   arg2 = (unsigned int)jarg2;
36939   {
36940     try {
36941       (arg1)->RemoveRenderer(arg2);
36942     } catch (std::out_of_range& e) {
36943       {
36944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36945       };
36946     } catch (std::exception& e) {
36947       {
36948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36949       };
36950     } catch (Dali::DaliException e) {
36951       {
36952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36953       };
36954     } catch (...) {
36955       {
36956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36957       };
36958     }
36959   }
36960
36961 }
36962
36963
36964 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchedSignal(void * jarg1) {
36965   void * jresult ;
36966   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36967   Dali::Actor::TouchSignalType *result = 0 ;
36968
36969   arg1 = (Dali::Actor *)jarg1;
36970   {
36971     try {
36972       result = (Dali::Actor::TouchSignalType *) &(arg1)->TouchedSignal();
36973     } catch (std::out_of_range& e) {
36974       {
36975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36976       };
36977     } catch (std::exception& e) {
36978       {
36979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36980       };
36981     } catch (Dali::DaliException e) {
36982       {
36983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36984       };
36985     } catch (...) {
36986       {
36987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36988       };
36989     }
36990   }
36991
36992   jresult = (void *)result;
36993   return jresult;
36994 }
36995
36996
36997 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchSignal(void * jarg1) {
36998   void * jresult ;
36999   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37000   Dali::Actor::TouchDataSignalType *result = 0 ;
37001
37002   arg1 = (Dali::Actor *)jarg1;
37003   {
37004     try {
37005       result = (Dali::Actor::TouchDataSignalType *) &(arg1)->TouchSignal();
37006     } catch (std::out_of_range& e) {
37007       {
37008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37009       };
37010     } catch (std::exception& e) {
37011       {
37012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37013       };
37014     } catch (Dali::DaliException e) {
37015       {
37016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37017       };
37018     } catch (...) {
37019       {
37020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37021       };
37022     }
37023   }
37024
37025   jresult = (void *)result;
37026   return jresult;
37027 }
37028
37029
37030 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_HoveredSignal(void * jarg1) {
37031   void * jresult ;
37032   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37033   Dali::Actor::HoverSignalType *result = 0 ;
37034
37035   arg1 = (Dali::Actor *)jarg1;
37036   {
37037     try {
37038       result = (Dali::Actor::HoverSignalType *) &(arg1)->HoveredSignal();
37039     } catch (std::out_of_range& e) {
37040       {
37041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37042       };
37043     } catch (std::exception& e) {
37044       {
37045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37046       };
37047     } catch (Dali::DaliException e) {
37048       {
37049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37050       };
37051     } catch (...) {
37052       {
37053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37054       };
37055     }
37056   }
37057
37058   jresult = (void *)result;
37059   return jresult;
37060 }
37061
37062
37063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_WheelEventSignal(void * jarg1) {
37064   void * jresult ;
37065   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37066   Dali::Actor::WheelEventSignalType *result = 0 ;
37067
37068   arg1 = (Dali::Actor *)jarg1;
37069   {
37070     try {
37071       result = (Dali::Actor::WheelEventSignalType *) &(arg1)->WheelEventSignal();
37072     } catch (std::out_of_range& e) {
37073       {
37074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37075       };
37076     } catch (std::exception& e) {
37077       {
37078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37079       };
37080     } catch (Dali::DaliException e) {
37081       {
37082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37083       };
37084     } catch (...) {
37085       {
37086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37087       };
37088     }
37089   }
37090
37091   jresult = (void *)result;
37092   return jresult;
37093 }
37094
37095
37096 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnStageSignal(void * jarg1) {
37097   void * jresult ;
37098   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37099   Dali::Actor::OnStageSignalType *result = 0 ;
37100
37101   arg1 = (Dali::Actor *)jarg1;
37102   {
37103     try {
37104       result = (Dali::Actor::OnStageSignalType *) &(arg1)->OnStageSignal();
37105     } catch (std::out_of_range& e) {
37106       {
37107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37108       };
37109     } catch (std::exception& e) {
37110       {
37111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37112       };
37113     } catch (Dali::DaliException e) {
37114       {
37115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37116       };
37117     } catch (...) {
37118       {
37119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37120       };
37121     }
37122   }
37123
37124   jresult = (void *)result;
37125   return jresult;
37126 }
37127
37128
37129 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OffStageSignal(void * jarg1) {
37130   void * jresult ;
37131   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37132   Dali::Actor::OffStageSignalType *result = 0 ;
37133
37134   arg1 = (Dali::Actor *)jarg1;
37135   {
37136     try {
37137       result = (Dali::Actor::OffStageSignalType *) &(arg1)->OffStageSignal();
37138     } catch (std::out_of_range& e) {
37139       {
37140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37141       };
37142     } catch (std::exception& e) {
37143       {
37144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37145       };
37146     } catch (Dali::DaliException e) {
37147       {
37148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37149       };
37150     } catch (...) {
37151       {
37152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37153       };
37154     }
37155   }
37156
37157   jresult = (void *)result;
37158   return jresult;
37159 }
37160
37161
37162 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnRelayoutSignal(void * jarg1) {
37163   void * jresult ;
37164   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37165   Dali::Actor::OnRelayoutSignalType *result = 0 ;
37166
37167   arg1 = (Dali::Actor *)jarg1;
37168   {
37169     try {
37170       result = (Dali::Actor::OnRelayoutSignalType *) &(arg1)->OnRelayoutSignal();
37171     } catch (std::out_of_range& e) {
37172       {
37173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37174       };
37175     } catch (std::exception& e) {
37176       {
37177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37178       };
37179     } catch (Dali::DaliException e) {
37180       {
37181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37182       };
37183     } catch (...) {
37184       {
37185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37186       };
37187     }
37188   }
37189
37190   jresult = (void *)result;
37191   return jresult;
37192 }
37193
37194
37195 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_UnparentAndReset(void * jarg1) {
37196   Dali::Actor *arg1 = 0 ;
37197
37198   arg1 = (Dali::Actor *)jarg1;
37199   if (!arg1) {
37200     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
37201     return ;
37202   }
37203   {
37204     try {
37205       Dali::UnparentAndReset(*arg1);
37206     } catch (std::out_of_range& e) {
37207       {
37208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37209       };
37210     } catch (std::exception& e) {
37211       {
37212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37213       };
37214     } catch (Dali::DaliException e) {
37215       {
37216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37217       };
37218     } catch (...) {
37219       {
37220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37221       };
37222     }
37223   }
37224
37225 }
37226
37227
37228 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_ENABLE_get() {
37229   int jresult ;
37230   int result;
37231
37232   result = (int)Dali::Layer::Property::CLIPPING_ENABLE;
37233   jresult = (int)result;
37234   return jresult;
37235 }
37236
37237
37238 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_BOX_get() {
37239   int jresult ;
37240   int result;
37241
37242   result = (int)Dali::Layer::Property::CLIPPING_BOX;
37243   jresult = (int)result;
37244   return jresult;
37245 }
37246
37247
37248 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_BEHAVIOR_get() {
37249   int jresult ;
37250   int result;
37251
37252   result = (int)Dali::Layer::Property::BEHAVIOR;
37253   jresult = (int)result;
37254   return jresult;
37255 }
37256
37257
37258 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer_Property() {
37259   void * jresult ;
37260   Dali::Layer::Property *result = 0 ;
37261
37262   {
37263     try {
37264       result = (Dali::Layer::Property *)new Dali::Layer::Property();
37265     } catch (std::out_of_range& e) {
37266       {
37267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37268       };
37269     } catch (std::exception& e) {
37270       {
37271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37272       };
37273     } catch (Dali::DaliException e) {
37274       {
37275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37276       };
37277     } catch (...) {
37278       {
37279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37280       };
37281     }
37282   }
37283
37284   jresult = (void *)result;
37285   return jresult;
37286 }
37287
37288
37289 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer_Property(void * jarg1) {
37290   Dali::Layer::Property *arg1 = (Dali::Layer::Property *) 0 ;
37291
37292   arg1 = (Dali::Layer::Property *)jarg1;
37293   {
37294     try {
37295       delete arg1;
37296     } catch (std::out_of_range& e) {
37297       {
37298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37299       };
37300     } catch (std::exception& e) {
37301       {
37302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37303       };
37304     } catch (Dali::DaliException e) {
37305       {
37306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37307       };
37308     } catch (...) {
37309       {
37310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37311       };
37312     }
37313   }
37314
37315 }
37316
37317
37318 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_0() {
37319   void * jresult ;
37320   Dali::Layer *result = 0 ;
37321
37322   {
37323     try {
37324       result = (Dali::Layer *)new Dali::Layer();
37325     } catch (std::out_of_range& e) {
37326       {
37327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37328       };
37329     } catch (std::exception& e) {
37330       {
37331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37332       };
37333     } catch (Dali::DaliException e) {
37334       {
37335         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37336       };
37337     } catch (...) {
37338       {
37339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37340       };
37341     }
37342   }
37343
37344   jresult = (void *)result;
37345   return jresult;
37346 }
37347
37348
37349 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_New() {
37350   void * jresult ;
37351   Dali::Layer result;
37352
37353   {
37354     try {
37355       result = Dali::Layer::New();
37356     } catch (std::out_of_range& e) {
37357       {
37358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37359       };
37360     } catch (std::exception& e) {
37361       {
37362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37363       };
37364     } catch (Dali::DaliException e) {
37365       {
37366         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37367       };
37368     } catch (...) {
37369       {
37370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37371       };
37372     }
37373   }
37374
37375   jresult = new Dali::Layer((const Dali::Layer &)result);
37376   return jresult;
37377 }
37378
37379
37380 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_DownCast(void * jarg1) {
37381   void * jresult ;
37382   Dali::BaseHandle arg1 ;
37383   Dali::BaseHandle *argp1 ;
37384   Dali::Layer result;
37385
37386   argp1 = (Dali::BaseHandle *)jarg1;
37387   if (!argp1) {
37388     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
37389     return 0;
37390   }
37391   arg1 = *argp1;
37392   {
37393     try {
37394       result = Dali::Layer::DownCast(arg1);
37395     } catch (std::out_of_range& e) {
37396       {
37397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37398       };
37399     } catch (std::exception& e) {
37400       {
37401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37402       };
37403     } catch (Dali::DaliException e) {
37404       {
37405         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37406       };
37407     } catch (...) {
37408       {
37409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37410       };
37411     }
37412   }
37413
37414   jresult = new Dali::Layer((const Dali::Layer &)result);
37415   return jresult;
37416 }
37417
37418
37419 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer(void * jarg1) {
37420   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37421
37422   arg1 = (Dali::Layer *)jarg1;
37423   {
37424     try {
37425       delete arg1;
37426     } catch (std::out_of_range& e) {
37427       {
37428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37429       };
37430     } catch (std::exception& e) {
37431       {
37432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37433       };
37434     } catch (Dali::DaliException e) {
37435       {
37436         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37437       };
37438     } catch (...) {
37439       {
37440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37441       };
37442     }
37443   }
37444
37445 }
37446
37447
37448 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_1(void * jarg1) {
37449   void * jresult ;
37450   Dali::Layer *arg1 = 0 ;
37451   Dali::Layer *result = 0 ;
37452
37453   arg1 = (Dali::Layer *)jarg1;
37454   if (!arg1) {
37455     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
37456     return 0;
37457   }
37458   {
37459     try {
37460       result = (Dali::Layer *)new Dali::Layer((Dali::Layer const &)*arg1);
37461     } catch (std::out_of_range& e) {
37462       {
37463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37464       };
37465     } catch (std::exception& e) {
37466       {
37467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37468       };
37469     } catch (Dali::DaliException e) {
37470       {
37471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37472       };
37473     } catch (...) {
37474       {
37475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37476       };
37477     }
37478   }
37479
37480   jresult = (void *)result;
37481   return jresult;
37482 }
37483
37484
37485 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_Assign(void * jarg1, void * jarg2) {
37486   void * jresult ;
37487   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37488   Dali::Layer *arg2 = 0 ;
37489   Dali::Layer *result = 0 ;
37490
37491   arg1 = (Dali::Layer *)jarg1;
37492   arg2 = (Dali::Layer *)jarg2;
37493   if (!arg2) {
37494     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
37495     return 0;
37496   }
37497   {
37498     try {
37499       result = (Dali::Layer *) &(arg1)->operator =((Dali::Layer const &)*arg2);
37500     } catch (std::out_of_range& e) {
37501       {
37502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37503       };
37504     } catch (std::exception& e) {
37505       {
37506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37507       };
37508     } catch (Dali::DaliException e) {
37509       {
37510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37511       };
37512     } catch (...) {
37513       {
37514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37515       };
37516     }
37517   }
37518
37519   jresult = (void *)result;
37520   return jresult;
37521 }
37522
37523
37524 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_GetDepth(void * jarg1) {
37525   unsigned int jresult ;
37526   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37527   unsigned int result;
37528
37529   arg1 = (Dali::Layer *)jarg1;
37530   {
37531     try {
37532       result = (unsigned int)((Dali::Layer const *)arg1)->GetDepth();
37533     } catch (std::out_of_range& e) {
37534       {
37535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37536       };
37537     } catch (std::exception& e) {
37538       {
37539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37540       };
37541     } catch (Dali::DaliException e) {
37542       {
37543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37544       };
37545     } catch (...) {
37546       {
37547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37548       };
37549     }
37550   }
37551
37552   jresult = result;
37553   return jresult;
37554 }
37555
37556
37557 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Raise(void * jarg1) {
37558   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37559
37560   arg1 = (Dali::Layer *)jarg1;
37561   {
37562     try {
37563       (arg1)->Raise();
37564     } catch (std::out_of_range& e) {
37565       {
37566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37567       };
37568     } catch (std::exception& e) {
37569       {
37570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37571       };
37572     } catch (Dali::DaliException e) {
37573       {
37574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37575       };
37576     } catch (...) {
37577       {
37578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37579       };
37580     }
37581   }
37582
37583 }
37584
37585
37586 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Lower(void * jarg1) {
37587   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37588
37589   arg1 = (Dali::Layer *)jarg1;
37590   {
37591     try {
37592       (arg1)->Lower();
37593     } catch (std::out_of_range& e) {
37594       {
37595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37596       };
37597     } catch (std::exception& e) {
37598       {
37599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37600       };
37601     } catch (Dali::DaliException e) {
37602       {
37603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37604       };
37605     } catch (...) {
37606       {
37607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37608       };
37609     }
37610   }
37611
37612 }
37613
37614
37615 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseAbove(void * jarg1, void * jarg2) {
37616   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37617   Dali::Layer arg2 ;
37618   Dali::Layer *argp2 ;
37619
37620   arg1 = (Dali::Layer *)jarg1;
37621   argp2 = (Dali::Layer *)jarg2;
37622   if (!argp2) {
37623     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37624     return ;
37625   }
37626   arg2 = *argp2;
37627   {
37628     try {
37629       (arg1)->RaiseAbove(arg2);
37630     } catch (std::out_of_range& e) {
37631       {
37632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37633       };
37634     } catch (std::exception& e) {
37635       {
37636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37637       };
37638     } catch (Dali::DaliException e) {
37639       {
37640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37641       };
37642     } catch (...) {
37643       {
37644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37645       };
37646     }
37647   }
37648
37649 }
37650
37651
37652 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerBelow(void * jarg1, void * jarg2) {
37653   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37654   Dali::Layer arg2 ;
37655   Dali::Layer *argp2 ;
37656
37657   arg1 = (Dali::Layer *)jarg1;
37658   argp2 = (Dali::Layer *)jarg2;
37659   if (!argp2) {
37660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37661     return ;
37662   }
37663   arg2 = *argp2;
37664   {
37665     try {
37666       (arg1)->LowerBelow(arg2);
37667     } catch (std::out_of_range& e) {
37668       {
37669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37670       };
37671     } catch (std::exception& e) {
37672       {
37673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37674       };
37675     } catch (Dali::DaliException e) {
37676       {
37677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37678       };
37679     } catch (...) {
37680       {
37681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37682       };
37683     }
37684   }
37685
37686 }
37687
37688
37689 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseToTop(void * jarg1) {
37690   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37691
37692   arg1 = (Dali::Layer *)jarg1;
37693   {
37694     try {
37695       (arg1)->RaiseToTop();
37696     } catch (std::out_of_range& e) {
37697       {
37698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37699       };
37700     } catch (std::exception& e) {
37701       {
37702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37703       };
37704     } catch (Dali::DaliException e) {
37705       {
37706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37707       };
37708     } catch (...) {
37709       {
37710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37711       };
37712     }
37713   }
37714
37715 }
37716
37717
37718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerToBottom(void * jarg1) {
37719   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37720
37721   arg1 = (Dali::Layer *)jarg1;
37722   {
37723     try {
37724       (arg1)->LowerToBottom();
37725     } catch (std::out_of_range& e) {
37726       {
37727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37728       };
37729     } catch (std::exception& e) {
37730       {
37731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37732       };
37733     } catch (Dali::DaliException e) {
37734       {
37735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37736       };
37737     } catch (...) {
37738       {
37739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37740       };
37741     }
37742   }
37743
37744 }
37745
37746
37747 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveAbove(void * jarg1, void * jarg2) {
37748   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37749   Dali::Layer arg2 ;
37750   Dali::Layer *argp2 ;
37751
37752   arg1 = (Dali::Layer *)jarg1;
37753   argp2 = (Dali::Layer *)jarg2;
37754   if (!argp2) {
37755     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37756     return ;
37757   }
37758   arg2 = *argp2;
37759   {
37760     try {
37761       (arg1)->MoveAbove(arg2);
37762     } catch (std::out_of_range& e) {
37763       {
37764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37765       };
37766     } catch (std::exception& e) {
37767       {
37768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37769       };
37770     } catch (Dali::DaliException e) {
37771       {
37772         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37773       };
37774     } catch (...) {
37775       {
37776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37777       };
37778     }
37779   }
37780
37781 }
37782
37783
37784 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveBelow(void * jarg1, void * jarg2) {
37785   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37786   Dali::Layer arg2 ;
37787   Dali::Layer *argp2 ;
37788
37789   arg1 = (Dali::Layer *)jarg1;
37790   argp2 = (Dali::Layer *)jarg2;
37791   if (!argp2) {
37792     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37793     return ;
37794   }
37795   arg2 = *argp2;
37796   {
37797     try {
37798       (arg1)->MoveBelow(arg2);
37799     } catch (std::out_of_range& e) {
37800       {
37801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37802       };
37803     } catch (std::exception& e) {
37804       {
37805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37806       };
37807     } catch (Dali::DaliException e) {
37808       {
37809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37810       };
37811     } catch (...) {
37812       {
37813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37814       };
37815     }
37816   }
37817
37818 }
37819
37820
37821 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetBehavior(void * jarg1, int jarg2) {
37822   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37823   Dali::Layer::Behavior arg2 ;
37824
37825   arg1 = (Dali::Layer *)jarg1;
37826   arg2 = (Dali::Layer::Behavior)jarg2;
37827   {
37828     try {
37829       (arg1)->SetBehavior(arg2);
37830     } catch (std::out_of_range& e) {
37831       {
37832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37833       };
37834     } catch (std::exception& e) {
37835       {
37836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37837       };
37838     } catch (Dali::DaliException e) {
37839       {
37840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37841       };
37842     } catch (...) {
37843       {
37844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37845       };
37846     }
37847   }
37848
37849 }
37850
37851
37852 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_GetBehavior(void * jarg1) {
37853   int jresult ;
37854   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37855   Dali::Layer::Behavior result;
37856
37857   arg1 = (Dali::Layer *)jarg1;
37858   {
37859     try {
37860       result = (Dali::Layer::Behavior)((Dali::Layer const *)arg1)->GetBehavior();
37861     } catch (std::out_of_range& e) {
37862       {
37863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37864       };
37865     } catch (std::exception& e) {
37866       {
37867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37868       };
37869     } catch (Dali::DaliException e) {
37870       {
37871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37872       };
37873     } catch (...) {
37874       {
37875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37876       };
37877     }
37878   }
37879
37880   jresult = (int)result;
37881   return jresult;
37882 }
37883
37884
37885 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClipping(void * jarg1, unsigned int jarg2) {
37886   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37887   bool arg2 ;
37888
37889   arg1 = (Dali::Layer *)jarg1;
37890   arg2 = jarg2 ? true : false;
37891   {
37892     try {
37893       (arg1)->SetClipping(arg2);
37894     } catch (std::out_of_range& e) {
37895       {
37896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37897       };
37898     } catch (std::exception& e) {
37899       {
37900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37901       };
37902     } catch (Dali::DaliException e) {
37903       {
37904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37905       };
37906     } catch (...) {
37907       {
37908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37909       };
37910     }
37911   }
37912
37913 }
37914
37915
37916 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsClipping(void * jarg1) {
37917   unsigned int jresult ;
37918   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37919   bool result;
37920
37921   arg1 = (Dali::Layer *)jarg1;
37922   {
37923     try {
37924       result = (bool)((Dali::Layer const *)arg1)->IsClipping();
37925     } catch (std::out_of_range& e) {
37926       {
37927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37928       };
37929     } catch (std::exception& e) {
37930       {
37931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37932       };
37933     } catch (Dali::DaliException e) {
37934       {
37935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37936       };
37937     } catch (...) {
37938       {
37939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37940       };
37941     }
37942   }
37943
37944   jresult = result;
37945   return jresult;
37946 }
37947
37948
37949 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_0(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
37950   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37951   int arg2 ;
37952   int arg3 ;
37953   int arg4 ;
37954   int arg5 ;
37955
37956   arg1 = (Dali::Layer *)jarg1;
37957   arg2 = (int)jarg2;
37958   arg3 = (int)jarg3;
37959   arg4 = (int)jarg4;
37960   arg5 = (int)jarg5;
37961   {
37962     try {
37963       (arg1)->SetClippingBox(arg2,arg3,arg4,arg5);
37964     } catch (std::out_of_range& e) {
37965       {
37966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37967       };
37968     } catch (std::exception& e) {
37969       {
37970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37971       };
37972     } catch (Dali::DaliException e) {
37973       {
37974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37975       };
37976     } catch (...) {
37977       {
37978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37979       };
37980     }
37981   }
37982
37983 }
37984
37985
37986 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_1(void * jarg1, void * jarg2) {
37987   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37988   Dali::ClippingBox arg2 ;
37989   Dali::ClippingBox *argp2 ;
37990
37991   arg1 = (Dali::Layer *)jarg1;
37992   argp2 = (Dali::ClippingBox *)jarg2;
37993   if (!argp2) {
37994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ClippingBox", 0);
37995     return ;
37996   }
37997   arg2 = *argp2;
37998   {
37999     try {
38000       (arg1)->SetClippingBox(arg2);
38001     } catch (std::out_of_range& e) {
38002       {
38003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38004       };
38005     } catch (std::exception& e) {
38006       {
38007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38008       };
38009     } catch (Dali::DaliException e) {
38010       {
38011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38012       };
38013     } catch (...) {
38014       {
38015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38016       };
38017     }
38018   }
38019
38020 }
38021
38022
38023 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_GetClippingBox(void * jarg1) {
38024   void * jresult ;
38025   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38026   Dali::ClippingBox result;
38027
38028   arg1 = (Dali::Layer *)jarg1;
38029   {
38030     try {
38031       result = ((Dali::Layer const *)arg1)->GetClippingBox();
38032     } catch (std::out_of_range& e) {
38033       {
38034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38035       };
38036     } catch (std::exception& e) {
38037       {
38038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38039       };
38040     } catch (Dali::DaliException e) {
38041       {
38042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38043       };
38044     } catch (...) {
38045       {
38046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38047       };
38048     }
38049   }
38050
38051   jresult = new Dali::ClippingBox((const Dali::ClippingBox &)result);
38052   return jresult;
38053 }
38054
38055
38056 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetDepthTestDisabled(void * jarg1, unsigned int jarg2) {
38057   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38058   bool arg2 ;
38059
38060   arg1 = (Dali::Layer *)jarg1;
38061   arg2 = jarg2 ? true : false;
38062   {
38063     try {
38064       (arg1)->SetDepthTestDisabled(arg2);
38065     } catch (std::out_of_range& e) {
38066       {
38067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38068       };
38069     } catch (std::exception& e) {
38070       {
38071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38072       };
38073     } catch (Dali::DaliException e) {
38074       {
38075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38076       };
38077     } catch (...) {
38078       {
38079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38080       };
38081     }
38082   }
38083
38084 }
38085
38086
38087 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsDepthTestDisabled(void * jarg1) {
38088   unsigned int jresult ;
38089   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38090   bool result;
38091
38092   arg1 = (Dali::Layer *)jarg1;
38093   {
38094     try {
38095       result = (bool)((Dali::Layer const *)arg1)->IsDepthTestDisabled();
38096     } catch (std::out_of_range& e) {
38097       {
38098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38099       };
38100     } catch (std::exception& e) {
38101       {
38102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38103       };
38104     } catch (Dali::DaliException e) {
38105       {
38106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38107       };
38108     } catch (...) {
38109       {
38110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38111       };
38112     }
38113   }
38114
38115   jresult = result;
38116   return jresult;
38117 }
38118
38119
38120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetSortFunction(void * jarg1, void * jarg2) {
38121   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38122   Dali::Layer::SortFunctionType arg2 = (Dali::Layer::SortFunctionType) 0 ;
38123
38124   arg1 = (Dali::Layer *)jarg1;
38125   arg2 = (Dali::Layer::SortFunctionType)jarg2;
38126   {
38127     try {
38128       (arg1)->SetSortFunction(arg2);
38129     } catch (std::out_of_range& e) {
38130       {
38131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38132       };
38133     } catch (std::exception& e) {
38134       {
38135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38136       };
38137     } catch (Dali::DaliException e) {
38138       {
38139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38140       };
38141     } catch (...) {
38142       {
38143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38144       };
38145     }
38146   }
38147
38148 }
38149
38150
38151 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetTouchConsumed(void * jarg1, unsigned int jarg2) {
38152   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38153   bool arg2 ;
38154
38155   arg1 = (Dali::Layer *)jarg1;
38156   arg2 = jarg2 ? true : false;
38157   {
38158     try {
38159       (arg1)->SetTouchConsumed(arg2);
38160     } catch (std::out_of_range& e) {
38161       {
38162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38163       };
38164     } catch (std::exception& e) {
38165       {
38166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38167       };
38168     } catch (Dali::DaliException e) {
38169       {
38170         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38171       };
38172     } catch (...) {
38173       {
38174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38175       };
38176     }
38177   }
38178
38179 }
38180
38181
38182 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsTouchConsumed(void * jarg1) {
38183   unsigned int jresult ;
38184   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38185   bool result;
38186
38187   arg1 = (Dali::Layer *)jarg1;
38188   {
38189     try {
38190       result = (bool)((Dali::Layer const *)arg1)->IsTouchConsumed();
38191     } catch (std::out_of_range& e) {
38192       {
38193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38194       };
38195     } catch (std::exception& e) {
38196       {
38197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38198       };
38199     } catch (Dali::DaliException e) {
38200       {
38201         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38202       };
38203     } catch (...) {
38204       {
38205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38206       };
38207     }
38208   }
38209
38210   jresult = result;
38211   return jresult;
38212 }
38213
38214
38215 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetHoverConsumed(void * jarg1, unsigned int jarg2) {
38216   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38217   bool arg2 ;
38218
38219   arg1 = (Dali::Layer *)jarg1;
38220   arg2 = jarg2 ? true : false;
38221   {
38222     try {
38223       (arg1)->SetHoverConsumed(arg2);
38224     } catch (std::out_of_range& e) {
38225       {
38226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38227       };
38228     } catch (std::exception& e) {
38229       {
38230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38231       };
38232     } catch (Dali::DaliException e) {
38233       {
38234         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38235       };
38236     } catch (...) {
38237       {
38238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38239       };
38240     }
38241   }
38242
38243 }
38244
38245
38246 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsHoverConsumed(void * jarg1) {
38247   unsigned int jresult ;
38248   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38249   bool result;
38250
38251   arg1 = (Dali::Layer *)jarg1;
38252   {
38253     try {
38254       result = (bool)((Dali::Layer const *)arg1)->IsHoverConsumed();
38255     } catch (std::out_of_range& e) {
38256       {
38257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38258       };
38259     } catch (std::exception& e) {
38260       {
38261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38262       };
38263     } catch (Dali::DaliException e) {
38264       {
38265         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38266       };
38267     } catch (...) {
38268       {
38269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38270       };
38271     }
38272   }
38273
38274   jresult = result;
38275   return jresult;
38276 }
38277
38278
38279 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEFAULT_BACKGROUND_COLOR_get() {
38280   void * jresult ;
38281   Dali::Vector4 *result = 0 ;
38282
38283   result = (Dali::Vector4 *)&Dali::Stage::DEFAULT_BACKGROUND_COLOR;
38284   jresult = (void *)result;
38285   return jresult;
38286 }
38287
38288
38289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEBUG_BACKGROUND_COLOR_get() {
38290   void * jresult ;
38291   Dali::Vector4 *result = 0 ;
38292
38293   result = (Dali::Vector4 *)&Dali::Stage::DEBUG_BACKGROUND_COLOR;
38294   jresult = (void *)result;
38295   return jresult;
38296 }
38297
38298
38299 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_0() {
38300   void * jresult ;
38301   Dali::Stage *result = 0 ;
38302
38303   {
38304     try {
38305       result = (Dali::Stage *)new Dali::Stage();
38306     } catch (std::out_of_range& e) {
38307       {
38308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38309       };
38310     } catch (std::exception& e) {
38311       {
38312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38313       };
38314     } catch (Dali::DaliException e) {
38315       {
38316         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38317       };
38318     } catch (...) {
38319       {
38320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38321       };
38322     }
38323   }
38324
38325   jresult = (void *)result;
38326   return jresult;
38327 }
38328
38329
38330 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetCurrent() {
38331   void * jresult ;
38332   Dali::Stage result;
38333
38334   {
38335     try {
38336       result = Dali::Stage::GetCurrent();
38337     } catch (std::out_of_range& e) {
38338       {
38339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38340       };
38341     } catch (std::exception& e) {
38342       {
38343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38344       };
38345     } catch (Dali::DaliException e) {
38346       {
38347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38348       };
38349     } catch (...) {
38350       {
38351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38352       };
38353     }
38354   }
38355
38356   jresult = new Dali::Stage((const Dali::Stage &)result);
38357   return jresult;
38358 }
38359
38360
38361 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_IsInstalled() {
38362   unsigned int jresult ;
38363   bool result;
38364
38365   {
38366     try {
38367       result = (bool)Dali::Stage::IsInstalled();
38368     } catch (std::out_of_range& e) {
38369       {
38370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38371       };
38372     } catch (std::exception& e) {
38373       {
38374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38375       };
38376     } catch (Dali::DaliException e) {
38377       {
38378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38379       };
38380     } catch (...) {
38381       {
38382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38383       };
38384     }
38385   }
38386
38387   jresult = result;
38388   return jresult;
38389 }
38390
38391
38392 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Stage(void * jarg1) {
38393   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38394
38395   arg1 = (Dali::Stage *)jarg1;
38396   {
38397     try {
38398       delete arg1;
38399     } catch (std::out_of_range& e) {
38400       {
38401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38402       };
38403     } catch (std::exception& e) {
38404       {
38405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38406       };
38407     } catch (Dali::DaliException e) {
38408       {
38409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38410       };
38411     } catch (...) {
38412       {
38413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38414       };
38415     }
38416   }
38417
38418 }
38419
38420
38421 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_1(void * jarg1) {
38422   void * jresult ;
38423   Dali::Stage *arg1 = 0 ;
38424   Dali::Stage *result = 0 ;
38425
38426   arg1 = (Dali::Stage *)jarg1;
38427   if (!arg1) {
38428     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
38429     return 0;
38430   }
38431   {
38432     try {
38433       result = (Dali::Stage *)new Dali::Stage((Dali::Stage const &)*arg1);
38434     } catch (std::out_of_range& e) {
38435       {
38436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38437       };
38438     } catch (std::exception& e) {
38439       {
38440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38441       };
38442     } catch (Dali::DaliException e) {
38443       {
38444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38445       };
38446     } catch (...) {
38447       {
38448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38449       };
38450     }
38451   }
38452
38453   jresult = (void *)result;
38454   return jresult;
38455 }
38456
38457
38458 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_Assign(void * jarg1, void * jarg2) {
38459   void * jresult ;
38460   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38461   Dali::Stage *arg2 = 0 ;
38462   Dali::Stage *result = 0 ;
38463
38464   arg1 = (Dali::Stage *)jarg1;
38465   arg2 = (Dali::Stage *)jarg2;
38466   if (!arg2) {
38467     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
38468     return 0;
38469   }
38470   {
38471     try {
38472       result = (Dali::Stage *) &(arg1)->operator =((Dali::Stage const &)*arg2);
38473     } catch (std::out_of_range& e) {
38474       {
38475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38476       };
38477     } catch (std::exception& e) {
38478       {
38479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38480       };
38481     } catch (Dali::DaliException e) {
38482       {
38483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38484       };
38485     } catch (...) {
38486       {
38487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38488       };
38489     }
38490   }
38491
38492   jresult = (void *)result;
38493   return jresult;
38494 }
38495
38496
38497 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Add(void * jarg1, void * jarg2) {
38498   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38499   Dali::Actor *arg2 = 0 ;
38500
38501   arg1 = (Dali::Stage *)jarg1;
38502   arg2 = (Dali::Actor *)jarg2;
38503   if (!arg2) {
38504     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
38505     return ;
38506   }
38507   {
38508     try {
38509       (arg1)->Add(*arg2);
38510     } catch (std::out_of_range& e) {
38511       {
38512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38513       };
38514     } catch (std::exception& e) {
38515       {
38516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38517       };
38518     } catch (Dali::DaliException e) {
38519       {
38520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38521       };
38522     } catch (...) {
38523       {
38524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38525       };
38526     }
38527   }
38528
38529 }
38530
38531
38532 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Remove(void * jarg1, void * jarg2) {
38533   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38534   Dali::Actor *arg2 = 0 ;
38535
38536   arg1 = (Dali::Stage *)jarg1;
38537   arg2 = (Dali::Actor *)jarg2;
38538   if (!arg2) {
38539     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
38540     return ;
38541   }
38542   {
38543     try {
38544       (arg1)->Remove(*arg2);
38545     } catch (std::out_of_range& e) {
38546       {
38547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38548       };
38549     } catch (std::exception& e) {
38550       {
38551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38552       };
38553     } catch (Dali::DaliException e) {
38554       {
38555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38556       };
38557     } catch (...) {
38558       {
38559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38560       };
38561     }
38562   }
38563
38564 }
38565
38566
38567 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetSize(void * jarg1) {
38568   void * jresult ;
38569   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38570   Dali::Vector2 result;
38571
38572   arg1 = (Dali::Stage *)jarg1;
38573   {
38574     try {
38575       result = ((Dali::Stage const *)arg1)->GetSize();
38576     } catch (std::out_of_range& e) {
38577       {
38578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38579       };
38580     } catch (std::exception& e) {
38581       {
38582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38583       };
38584     } catch (Dali::DaliException e) {
38585       {
38586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38587       };
38588     } catch (...) {
38589       {
38590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38591       };
38592     }
38593   }
38594
38595   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
38596   return jresult;
38597 }
38598
38599
38600 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRenderTaskList(void * jarg1) {
38601   void * jresult ;
38602   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38603   Dali::RenderTaskList result;
38604
38605   arg1 = (Dali::Stage *)jarg1;
38606   {
38607     try {
38608       result = ((Dali::Stage const *)arg1)->GetRenderTaskList();
38609     } catch (std::out_of_range& e) {
38610       {
38611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38612       };
38613     } catch (std::exception& e) {
38614       {
38615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38616       };
38617     } catch (Dali::DaliException e) {
38618       {
38619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38620       };
38621     } catch (...) {
38622       {
38623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38624       };
38625     }
38626   }
38627
38628   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
38629   return jresult;
38630 }
38631
38632
38633 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_GetLayerCount(void * jarg1) {
38634   unsigned int jresult ;
38635   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38636   unsigned int result;
38637
38638   arg1 = (Dali::Stage *)jarg1;
38639   {
38640     try {
38641       result = (unsigned int)((Dali::Stage const *)arg1)->GetLayerCount();
38642     } catch (std::out_of_range& e) {
38643       {
38644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38645       };
38646     } catch (std::exception& e) {
38647       {
38648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38649       };
38650     } catch (Dali::DaliException e) {
38651       {
38652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38653       };
38654     } catch (...) {
38655       {
38656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38657       };
38658     }
38659   }
38660
38661   jresult = result;
38662   return jresult;
38663 }
38664
38665
38666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetLayer(void * jarg1, unsigned int jarg2) {
38667   void * jresult ;
38668   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38669   unsigned int arg2 ;
38670   Dali::Layer result;
38671
38672   arg1 = (Dali::Stage *)jarg1;
38673   arg2 = (unsigned int)jarg2;
38674   {
38675     try {
38676       result = ((Dali::Stage const *)arg1)->GetLayer(arg2);
38677     } catch (std::out_of_range& e) {
38678       {
38679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38680       };
38681     } catch (std::exception& e) {
38682       {
38683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38684       };
38685     } catch (Dali::DaliException e) {
38686       {
38687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38688       };
38689     } catch (...) {
38690       {
38691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38692       };
38693     }
38694   }
38695
38696   jresult = new Dali::Layer((const Dali::Layer &)result);
38697   return jresult;
38698 }
38699
38700
38701 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRootLayer(void * jarg1) {
38702   void * jresult ;
38703   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38704   Dali::Layer result;
38705
38706   arg1 = (Dali::Stage *)jarg1;
38707   {
38708     try {
38709       result = ((Dali::Stage const *)arg1)->GetRootLayer();
38710     } catch (std::out_of_range& e) {
38711       {
38712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38713       };
38714     } catch (std::exception& e) {
38715       {
38716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38717       };
38718     } catch (Dali::DaliException e) {
38719       {
38720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38721       };
38722     } catch (...) {
38723       {
38724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38725       };
38726     }
38727   }
38728
38729   jresult = new Dali::Layer((const Dali::Layer &)result);
38730   return jresult;
38731 }
38732
38733
38734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetBackgroundColor(void * jarg1, void * jarg2) {
38735   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38736   Dali::Vector4 arg2 ;
38737   Dali::Vector4 *argp2 ;
38738
38739   arg1 = (Dali::Stage *)jarg1;
38740   argp2 = (Dali::Vector4 *)jarg2;
38741   if (!argp2) {
38742     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector4", 0);
38743     return ;
38744   }
38745   arg2 = *argp2;
38746   {
38747     try {
38748       (arg1)->SetBackgroundColor(arg2);
38749     } catch (std::out_of_range& e) {
38750       {
38751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38752       };
38753     } catch (std::exception& e) {
38754       {
38755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38756       };
38757     } catch (Dali::DaliException e) {
38758       {
38759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38760       };
38761     } catch (...) {
38762       {
38763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38764       };
38765     }
38766   }
38767
38768 }
38769
38770
38771 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetBackgroundColor(void * jarg1) {
38772   void * jresult ;
38773   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38774   Dali::Vector4 result;
38775
38776   arg1 = (Dali::Stage *)jarg1;
38777   {
38778     try {
38779       result = ((Dali::Stage const *)arg1)->GetBackgroundColor();
38780     } catch (std::out_of_range& e) {
38781       {
38782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38783       };
38784     } catch (std::exception& e) {
38785       {
38786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38787       };
38788     } catch (Dali::DaliException e) {
38789       {
38790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38791       };
38792     } catch (...) {
38793       {
38794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38795       };
38796     }
38797   }
38798
38799   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
38800   return jresult;
38801 }
38802
38803
38804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetDpi(void * jarg1) {
38805   void * jresult ;
38806   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38807   Dali::Vector2 result;
38808
38809   arg1 = (Dali::Stage *)jarg1;
38810   {
38811     try {
38812       result = ((Dali::Stage const *)arg1)->GetDpi();
38813     } catch (std::out_of_range& e) {
38814       {
38815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38816       };
38817     } catch (std::exception& e) {
38818       {
38819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38820       };
38821     } catch (Dali::DaliException e) {
38822       {
38823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38824       };
38825     } catch (...) {
38826       {
38827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38828       };
38829     }
38830   }
38831
38832   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
38833   return jresult;
38834 }
38835
38836
38837 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetObjectRegistry(void * jarg1) {
38838   void * jresult ;
38839   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38840   Dali::ObjectRegistry result;
38841
38842   arg1 = (Dali::Stage *)jarg1;
38843   {
38844     try {
38845       result = ((Dali::Stage const *)arg1)->GetObjectRegistry();
38846     } catch (std::out_of_range& e) {
38847       {
38848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38849       };
38850     } catch (std::exception& e) {
38851       {
38852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38853       };
38854     } catch (Dali::DaliException e) {
38855       {
38856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38857       };
38858     } catch (...) {
38859       {
38860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38861       };
38862     }
38863   }
38864
38865   jresult = new Dali::ObjectRegistry((const Dali::ObjectRegistry &)result);
38866   return jresult;
38867 }
38868
38869
38870 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_KeepRendering(void * jarg1, float jarg2) {
38871   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38872   float arg2 ;
38873
38874   arg1 = (Dali::Stage *)jarg1;
38875   arg2 = (float)jarg2;
38876   {
38877     try {
38878       (arg1)->KeepRendering(arg2);
38879     } catch (std::out_of_range& e) {
38880       {
38881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38882       };
38883     } catch (std::exception& e) {
38884       {
38885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38886       };
38887     } catch (Dali::DaliException e) {
38888       {
38889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38890       };
38891     } catch (...) {
38892       {
38893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38894       };
38895     }
38896   }
38897
38898 }
38899
38900
38901 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_KeyEventSignal(void * jarg1) {
38902   void * jresult ;
38903   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38904   Dali::Stage::KeyEventSignalType *result = 0 ;
38905
38906   arg1 = (Dali::Stage *)jarg1;
38907   {
38908     try {
38909       result = (Dali::Stage::KeyEventSignalType *) &(arg1)->KeyEventSignal();
38910     } catch (std::out_of_range& e) {
38911       {
38912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38913       };
38914     } catch (std::exception& e) {
38915       {
38916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38917       };
38918     } catch (Dali::DaliException e) {
38919       {
38920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38921       };
38922     } catch (...) {
38923       {
38924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38925       };
38926     }
38927   }
38928
38929   jresult = (void *)result;
38930   return jresult;
38931 }
38932
38933
38934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_EventProcessingFinishedSignal(void * jarg1) {
38935   void * jresult ;
38936   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38937   Dali::Stage::EventProcessingFinishedSignalType *result = 0 ;
38938
38939   arg1 = (Dali::Stage *)jarg1;
38940   {
38941     try {
38942       result = (Dali::Stage::EventProcessingFinishedSignalType *) &(arg1)->EventProcessingFinishedSignal();
38943     } catch (std::out_of_range& e) {
38944       {
38945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38946       };
38947     } catch (std::exception& e) {
38948       {
38949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38950       };
38951     } catch (Dali::DaliException e) {
38952       {
38953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38954       };
38955     } catch (...) {
38956       {
38957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38958       };
38959     }
38960   }
38961
38962   jresult = (void *)result;
38963   return jresult;
38964 }
38965
38966
38967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_TouchSignal(void * jarg1) {
38968   void * jresult ;
38969   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38970   Dali::Stage::TouchSignalType *result = 0 ;
38971
38972   arg1 = (Dali::Stage *)jarg1;
38973   {
38974     try {
38975       result = (Dali::Stage::TouchSignalType *) &(arg1)->TouchSignal();
38976     } catch (std::out_of_range& e) {
38977       {
38978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38979       };
38980     } catch (std::exception& e) {
38981       {
38982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38983       };
38984     } catch (Dali::DaliException e) {
38985       {
38986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38987       };
38988     } catch (...) {
38989       {
38990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38991       };
38992     }
38993   }
38994
38995   jresult = (void *)result;
38996   return jresult;
38997 }
38998
38999
39000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_WheelEventSignal(void * jarg1) {
39001   void * jresult ;
39002   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39003   Dali::Stage::WheelEventSignalType *result = 0 ;
39004
39005   arg1 = (Dali::Stage *)jarg1;
39006   {
39007     try {
39008       result = (Dali::Stage::WheelEventSignalType *) &(arg1)->WheelEventSignal();
39009     } catch (std::out_of_range& e) {
39010       {
39011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39012       };
39013     } catch (std::exception& e) {
39014       {
39015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39016       };
39017     } catch (Dali::DaliException e) {
39018       {
39019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39020       };
39021     } catch (...) {
39022       {
39023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39024       };
39025     }
39026   }
39027
39028   jresult = (void *)result;
39029   return jresult;
39030 }
39031
39032
39033 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextLostSignal(void * jarg1) {
39034   void * jresult ;
39035   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39036   Dali::Stage::ContextStatusSignal *result = 0 ;
39037
39038   arg1 = (Dali::Stage *)jarg1;
39039   {
39040     try {
39041       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextLostSignal();
39042     } catch (std::out_of_range& e) {
39043       {
39044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39045       };
39046     } catch (std::exception& e) {
39047       {
39048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39049       };
39050     } catch (Dali::DaliException e) {
39051       {
39052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39053       };
39054     } catch (...) {
39055       {
39056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39057       };
39058     }
39059   }
39060
39061   jresult = (void *)result;
39062   return jresult;
39063 }
39064
39065
39066 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextRegainedSignal(void * jarg1) {
39067   void * jresult ;
39068   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39069   Dali::Stage::ContextStatusSignal *result = 0 ;
39070
39071   arg1 = (Dali::Stage *)jarg1;
39072   {
39073     try {
39074       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextRegainedSignal();
39075     } catch (std::out_of_range& e) {
39076       {
39077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39078       };
39079     } catch (std::exception& e) {
39080       {
39081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39082       };
39083     } catch (Dali::DaliException e) {
39084       {
39085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39086       };
39087     } catch (...) {
39088       {
39089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39090       };
39091     }
39092   }
39093
39094   jresult = (void *)result;
39095   return jresult;
39096 }
39097
39098
39099 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_SceneCreatedSignal(void * jarg1) {
39100   void * jresult ;
39101   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39102   Dali::Stage::SceneCreatedSignalType *result = 0 ;
39103
39104   arg1 = (Dali::Stage *)jarg1;
39105   {
39106     try {
39107       result = (Dali::Stage::SceneCreatedSignalType *) &(arg1)->SceneCreatedSignal();
39108     } catch (std::out_of_range& e) {
39109       {
39110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39111       };
39112     } catch (std::exception& e) {
39113       {
39114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39115       };
39116     } catch (Dali::DaliException e) {
39117       {
39118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39119       };
39120     } catch (...) {
39121       {
39122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39123       };
39124     }
39125   }
39126
39127   jresult = (void *)result;
39128   return jresult;
39129 }
39130
39131
39132 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RelayoutContainer(void * jarg1) {
39133   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
39134
39135   arg1 = (Dali::RelayoutContainer *)jarg1;
39136   {
39137     try {
39138       delete arg1;
39139     } catch (std::out_of_range& e) {
39140       {
39141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39142       };
39143     } catch (std::exception& e) {
39144       {
39145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39146       };
39147     } catch (Dali::DaliException e) {
39148       {
39149         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39150       };
39151     } catch (...) {
39152       {
39153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39154       };
39155     }
39156   }
39157
39158 }
39159
39160
39161 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RelayoutContainer_Add(void * jarg1, void * jarg2, void * jarg3) {
39162   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
39163   Dali::Actor *arg2 = 0 ;
39164   Dali::Vector2 *arg3 = 0 ;
39165
39166   arg1 = (Dali::RelayoutContainer *)jarg1;
39167   arg2 = (Dali::Actor *)jarg2;
39168   if (!arg2) {
39169     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
39170     return ;
39171   }
39172   arg3 = (Dali::Vector2 *)jarg3;
39173   if (!arg3) {
39174     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
39175     return ;
39176   }
39177   {
39178     try {
39179       (arg1)->Add((Dali::Actor const &)*arg2,(Dali::Vector2 const &)*arg3);
39180     } catch (std::out_of_range& e) {
39181       {
39182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39183       };
39184     } catch (std::exception& e) {
39185       {
39186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39187       };
39188     } catch (Dali::DaliException e) {
39189       {
39190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39191       };
39192     } catch (...) {
39193       {
39194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39195       };
39196     }
39197   }
39198
39199 }
39200
39201
39202 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_Self(void * jarg1) {
39203   void * jresult ;
39204   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39205   Dali::CustomActor result;
39206
39207   arg1 = (Dali::CustomActorImpl *)jarg1;
39208   {
39209     try {
39210       result = ((Dali::CustomActorImpl const *)arg1)->Self();
39211     } catch (std::out_of_range& e) {
39212       {
39213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39214       };
39215     } catch (std::exception& e) {
39216       {
39217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39218       };
39219     } catch (Dali::DaliException e) {
39220       {
39221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39222       };
39223     } catch (...) {
39224       {
39225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39226       };
39227     }
39228   }
39229
39230   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
39231   return jresult;
39232 }
39233
39234
39235 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageConnection(void * jarg1, int jarg2) {
39236   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39237   int arg2 ;
39238
39239   arg1 = (Dali::CustomActorImpl *)jarg1;
39240   arg2 = (int)jarg2;
39241   {
39242     try {
39243       (arg1)->OnStageConnection(arg2);
39244     } catch (std::out_of_range& e) {
39245       {
39246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39247       };
39248     } catch (std::exception& e) {
39249       {
39250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39251       };
39252     } catch (Dali::DaliException e) {
39253       {
39254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39255       };
39256     } catch (...) {
39257       {
39258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39259       };
39260     }
39261   }
39262
39263 }
39264
39265
39266 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageDisconnection(void * jarg1) {
39267   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39268
39269   arg1 = (Dali::CustomActorImpl *)jarg1;
39270   {
39271     try {
39272       (arg1)->OnStageDisconnection();
39273     } catch (std::out_of_range& e) {
39274       {
39275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39276       };
39277     } catch (std::exception& e) {
39278       {
39279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39280       };
39281     } catch (Dali::DaliException e) {
39282       {
39283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39284       };
39285     } catch (...) {
39286       {
39287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39288       };
39289     }
39290   }
39291
39292 }
39293
39294
39295 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildAdd(void * jarg1, void * jarg2) {
39296   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39297   Dali::Actor *arg2 = 0 ;
39298
39299   arg1 = (Dali::CustomActorImpl *)jarg1;
39300   arg2 = (Dali::Actor *)jarg2;
39301   if (!arg2) {
39302     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
39303     return ;
39304   }
39305   {
39306     try {
39307       (arg1)->OnChildAdd(*arg2);
39308     } catch (std::out_of_range& e) {
39309       {
39310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39311       };
39312     } catch (std::exception& e) {
39313       {
39314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39315       };
39316     } catch (Dali::DaliException e) {
39317       {
39318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39319       };
39320     } catch (...) {
39321       {
39322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39323       };
39324     }
39325   }
39326
39327 }
39328
39329
39330 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildRemove(void * jarg1, void * jarg2) {
39331   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39332   Dali::Actor *arg2 = 0 ;
39333
39334   arg1 = (Dali::CustomActorImpl *)jarg1;
39335   arg2 = (Dali::Actor *)jarg2;
39336   if (!arg2) {
39337     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
39338     return ;
39339   }
39340   {
39341     try {
39342       (arg1)->OnChildRemove(*arg2);
39343     } catch (std::out_of_range& e) {
39344       {
39345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39346       };
39347     } catch (std::exception& e) {
39348       {
39349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39350       };
39351     } catch (Dali::DaliException e) {
39352       {
39353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39354       };
39355     } catch (...) {
39356       {
39357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39358       };
39359     }
39360   }
39361
39362 }
39363
39364
39365 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
39366   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39367   Dali::Property::Index arg2 ;
39368   Dali::Property::Value arg3 ;
39369   Dali::Property::Value *argp3 ;
39370
39371   arg1 = (Dali::CustomActorImpl *)jarg1;
39372   arg2 = (Dali::Property::Index)jarg2;
39373   argp3 = (Dali::Property::Value *)jarg3;
39374   if (!argp3) {
39375     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39376     return ;
39377   }
39378   arg3 = *argp3;
39379   {
39380     try {
39381       (arg1)->OnPropertySet(arg2,arg3);
39382     } catch (std::out_of_range& e) {
39383       {
39384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39385       };
39386     } catch (std::exception& e) {
39387       {
39388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39389       };
39390     } catch (Dali::DaliException e) {
39391       {
39392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39393       };
39394     } catch (...) {
39395       {
39396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39397       };
39398     }
39399   }
39400
39401 }
39402
39403
39404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeSet(void * jarg1, void * jarg2) {
39405   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39406   Dali::Vector3 *arg2 = 0 ;
39407
39408   arg1 = (Dali::CustomActorImpl *)jarg1;
39409   arg2 = (Dali::Vector3 *)jarg2;
39410   if (!arg2) {
39411     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
39412     return ;
39413   }
39414   {
39415     try {
39416       (arg1)->OnSizeSet((Dali::Vector3 const &)*arg2);
39417     } catch (std::out_of_range& e) {
39418       {
39419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39420       };
39421     } catch (std::exception& e) {
39422       {
39423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39424       };
39425     } catch (Dali::DaliException e) {
39426       {
39427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39428       };
39429     } catch (...) {
39430       {
39431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39432       };
39433     }
39434   }
39435
39436 }
39437
39438 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
39439   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39440   Dali::Animation *arg2 = 0 ;
39441   Dali::Vector3 *arg3 = 0 ;
39442
39443   arg1 = (Dali::CustomActorImpl *)jarg1;
39444   arg2 = (Dali::Animation *)jarg2;
39445   if (!arg2) {
39446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
39447     return ;
39448   }
39449   arg3 = (Dali::Vector3 *)jarg3;
39450   if (!arg3) {
39451     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
39452     return ;
39453   }
39454   {
39455     try {
39456       (arg1)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
39457     } catch (std::out_of_range& e) {
39458       {
39459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39460       };
39461     } catch (std::exception& e) {
39462       {
39463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39464       };
39465     } catch (Dali::DaliException e) {
39466       {
39467         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39468       };
39469     } catch (...) {
39470       {
39471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39472       };
39473     }
39474   }
39475
39476 }
39477
39478
39479 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnTouchEvent(void * jarg1, void * jarg2) {
39480   unsigned int jresult ;
39481   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39482   Dali::TouchEvent *arg2 = 0 ;
39483   bool result;
39484
39485   arg1 = (Dali::CustomActorImpl *)jarg1;
39486   arg2 = (Dali::TouchEvent *)jarg2;
39487   if (!arg2) {
39488     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
39489     return 0;
39490   }
39491   {
39492     try {
39493       result = (bool)(arg1)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
39494     } catch (std::out_of_range& e) {
39495       {
39496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39497       };
39498     } catch (std::exception& e) {
39499       {
39500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39501       };
39502     } catch (Dali::DaliException e) {
39503       {
39504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39505       };
39506     } catch (...) {
39507       {
39508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39509       };
39510     }
39511   }
39512
39513   jresult = result;
39514   return jresult;
39515 }
39516
39517
39518 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnHoverEvent(void * jarg1, void * jarg2) {
39519   unsigned int jresult ;
39520   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39521   Dali::HoverEvent *arg2 = 0 ;
39522   bool result;
39523
39524   arg1 = (Dali::CustomActorImpl *)jarg1;
39525   arg2 = (Dali::HoverEvent *)jarg2;
39526   if (!arg2) {
39527     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
39528     return 0;
39529   }
39530   {
39531     try {
39532       result = (bool)(arg1)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
39533     } catch (std::out_of_range& e) {
39534       {
39535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39536       };
39537     } catch (std::exception& e) {
39538       {
39539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39540       };
39541     } catch (Dali::DaliException e) {
39542       {
39543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39544       };
39545     } catch (...) {
39546       {
39547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39548       };
39549     }
39550   }
39551
39552   jresult = result;
39553   return jresult;
39554 }
39555
39556
39557 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnKeyEvent(void * jarg1, void * jarg2) {
39558   unsigned int jresult ;
39559   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39560   Dali::KeyEvent *arg2 = 0 ;
39561   bool result;
39562
39563   arg1 = (Dali::CustomActorImpl *)jarg1;
39564   arg2 = (Dali::KeyEvent *)jarg2;
39565   if (!arg2) {
39566     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
39567     return 0;
39568   }
39569   {
39570     try {
39571       result = (bool)(arg1)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
39572     } catch (std::out_of_range& e) {
39573       {
39574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39575       };
39576     } catch (std::exception& e) {
39577       {
39578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39579       };
39580     } catch (Dali::DaliException e) {
39581       {
39582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39583       };
39584     } catch (...) {
39585       {
39586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39587       };
39588     }
39589   }
39590
39591   jresult = result;
39592   return jresult;
39593 }
39594
39595
39596 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnWheelEvent(void * jarg1, void * jarg2) {
39597   unsigned int jresult ;
39598   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39599   Dali::WheelEvent *arg2 = 0 ;
39600   bool result;
39601
39602   arg1 = (Dali::CustomActorImpl *)jarg1;
39603   arg2 = (Dali::WheelEvent *)jarg2;
39604   if (!arg2) {
39605     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
39606     return 0;
39607   }
39608   {
39609     try {
39610       result = (bool)(arg1)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
39611     } catch (std::out_of_range& e) {
39612       {
39613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39614       };
39615     } catch (std::exception& e) {
39616       {
39617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39618       };
39619     } catch (Dali::DaliException e) {
39620       {
39621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39622       };
39623     } catch (...) {
39624       {
39625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39626       };
39627     }
39628   }
39629
39630   jresult = result;
39631   return jresult;
39632 }
39633
39634
39635 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
39636   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39637   Dali::Vector2 *arg2 = 0 ;
39638   Dali::RelayoutContainer *arg3 = 0 ;
39639
39640   arg1 = (Dali::CustomActorImpl *)jarg1;
39641   arg2 = (Dali::Vector2 *)jarg2;
39642   if (!arg2) {
39643     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
39644     return ;
39645   }
39646   arg3 = (Dali::RelayoutContainer *)jarg3;
39647   if (!arg3) {
39648     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
39649     return ;
39650   }
39651   {
39652     try {
39653       (arg1)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
39654     } catch (std::out_of_range& e) {
39655       {
39656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39657       };
39658     } catch (std::exception& e) {
39659       {
39660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39661       };
39662     } catch (Dali::DaliException e) {
39663       {
39664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39665       };
39666     } catch (...) {
39667       {
39668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39669       };
39670     }
39671   }
39672
39673 }
39674
39675
39676 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
39677   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39678   Dali::ResizePolicy::Type arg2 ;
39679   Dali::Dimension::Type arg3 ;
39680
39681   arg1 = (Dali::CustomActorImpl *)jarg1;
39682   arg2 = (Dali::ResizePolicy::Type)jarg2;
39683   arg3 = (Dali::Dimension::Type)jarg3;
39684   {
39685     try {
39686       (arg1)->OnSetResizePolicy(arg2,arg3);
39687     } catch (std::out_of_range& e) {
39688       {
39689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39690       };
39691     } catch (std::exception& e) {
39692       {
39693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39694       };
39695     } catch (Dali::DaliException e) {
39696       {
39697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39698       };
39699     } catch (...) {
39700       {
39701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39702       };
39703     }
39704   }
39705
39706 }
39707
39708
39709 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetNaturalSize(void * jarg1) {
39710   void * jresult ;
39711   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39712   Dali::Vector3 result;
39713
39714   arg1 = (Dali::CustomActorImpl *)jarg1;
39715   {
39716     try {
39717       result = (arg1)->GetNaturalSize();
39718     } catch (std::out_of_range& e) {
39719       {
39720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39721       };
39722     } catch (std::exception& e) {
39723       {
39724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39725       };
39726     } catch (Dali::DaliException e) {
39727       {
39728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39729       };
39730     } catch (...) {
39731       {
39732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39733       };
39734     }
39735   }
39736
39737   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
39738   return jresult;
39739 }
39740
39741
39742 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
39743   float jresult ;
39744   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39745   Dali::Actor *arg2 = 0 ;
39746   Dali::Dimension::Type arg3 ;
39747   float result;
39748
39749   arg1 = (Dali::CustomActorImpl *)jarg1;
39750   arg2 = (Dali::Actor *)jarg2;
39751   if (!arg2) {
39752     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
39753     return 0;
39754   }
39755   arg3 = (Dali::Dimension::Type)jarg3;
39756   {
39757     try {
39758       result = (float)(arg1)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
39759     } catch (std::out_of_range& e) {
39760       {
39761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39762       };
39763     } catch (std::exception& e) {
39764       {
39765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39766       };
39767     } catch (Dali::DaliException e) {
39768       {
39769         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39770       };
39771     } catch (...) {
39772       {
39773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39774       };
39775     }
39776   }
39777
39778   jresult = result;
39779   return jresult;
39780 }
39781
39782
39783 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetHeightForWidth(void * jarg1, float jarg2) {
39784   float jresult ;
39785   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39786   float arg2 ;
39787   float result;
39788
39789   arg1 = (Dali::CustomActorImpl *)jarg1;
39790   arg2 = (float)jarg2;
39791   {
39792     try {
39793       result = (float)(arg1)->GetHeightForWidth(arg2);
39794     } catch (std::out_of_range& e) {
39795       {
39796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39797       };
39798     } catch (std::exception& e) {
39799       {
39800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39801       };
39802     } catch (Dali::DaliException e) {
39803       {
39804         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39805       };
39806     } catch (...) {
39807       {
39808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39809       };
39810     }
39811   }
39812
39813   jresult = result;
39814   return jresult;
39815 }
39816
39817
39818 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetWidthForHeight(void * jarg1, float jarg2) {
39819   float jresult ;
39820   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39821   float arg2 ;
39822   float result;
39823
39824   arg1 = (Dali::CustomActorImpl *)jarg1;
39825   arg2 = (float)jarg2;
39826   {
39827     try {
39828       result = (float)(arg1)->GetWidthForHeight(arg2);
39829     } catch (std::out_of_range& e) {
39830       {
39831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39832       };
39833     } catch (std::exception& e) {
39834       {
39835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39836       };
39837     } catch (Dali::DaliException e) {
39838       {
39839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39840       };
39841     } catch (...) {
39842       {
39843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39844       };
39845     }
39846   }
39847
39848   jresult = result;
39849   return jresult;
39850 }
39851
39852
39853 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
39854   unsigned int jresult ;
39855   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39856   Dali::Dimension::Type arg2 ;
39857   bool result;
39858
39859   arg1 = (Dali::CustomActorImpl *)jarg1;
39860   arg2 = (Dali::Dimension::Type)jarg2;
39861   {
39862     try {
39863       result = (bool)(arg1)->RelayoutDependentOnChildren(arg2);
39864     } catch (std::out_of_range& e) {
39865       {
39866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39867       };
39868     } catch (std::exception& e) {
39869       {
39870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39871       };
39872     } catch (Dali::DaliException e) {
39873       {
39874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39875       };
39876     } catch (...) {
39877       {
39878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39879       };
39880     }
39881   }
39882
39883   jresult = result;
39884   return jresult;
39885 }
39886
39887
39888 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
39889   unsigned int jresult ;
39890   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39891   bool result;
39892
39893   arg1 = (Dali::CustomActorImpl *)jarg1;
39894   {
39895     try {
39896       result = (bool)(arg1)->RelayoutDependentOnChildren();
39897     } catch (std::out_of_range& e) {
39898       {
39899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39900       };
39901     } catch (std::exception& e) {
39902       {
39903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39904       };
39905     } catch (Dali::DaliException e) {
39906       {
39907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39908       };
39909     } catch (...) {
39910       {
39911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39912       };
39913     }
39914   }
39915
39916   jresult = result;
39917   return jresult;
39918 }
39919
39920
39921 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
39922   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39923   Dali::Dimension::Type arg2 ;
39924
39925   arg1 = (Dali::CustomActorImpl *)jarg1;
39926   arg2 = (Dali::Dimension::Type)jarg2;
39927   {
39928     try {
39929       (arg1)->OnCalculateRelayoutSize(arg2);
39930     } catch (std::out_of_range& e) {
39931       {
39932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39933       };
39934     } catch (std::exception& e) {
39935       {
39936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39937       };
39938     } catch (Dali::DaliException e) {
39939       {
39940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39941       };
39942     } catch (...) {
39943       {
39944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39945       };
39946     }
39947   }
39948
39949 }
39950
39951
39952 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
39953   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39954   float arg2 ;
39955   Dali::Dimension::Type arg3 ;
39956
39957   arg1 = (Dali::CustomActorImpl *)jarg1;
39958   arg2 = (float)jarg2;
39959   arg3 = (Dali::Dimension::Type)jarg3;
39960   {
39961     try {
39962       (arg1)->OnLayoutNegotiated(arg2,arg3);
39963     } catch (std::out_of_range& e) {
39964       {
39965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39966       };
39967     } catch (std::exception& e) {
39968       {
39969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39970       };
39971     } catch (Dali::DaliException e) {
39972       {
39973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39974       };
39975     } catch (...) {
39976       {
39977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39978       };
39979     }
39980   }
39981
39982 }
39983
39984
39985 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresTouchEvents(void * jarg1) {
39986   unsigned int jresult ;
39987   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39988   bool result;
39989
39990   arg1 = (Dali::CustomActorImpl *)jarg1;
39991   {
39992     try {
39993       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresTouchEvents();
39994     } catch (std::out_of_range& e) {
39995       {
39996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39997       };
39998     } catch (std::exception& e) {
39999       {
40000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40001       };
40002     } catch (Dali::DaliException e) {
40003       {
40004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40005       };
40006     } catch (...) {
40007       {
40008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40009       };
40010     }
40011   }
40012
40013   jresult = result;
40014   return jresult;
40015 }
40016
40017
40018 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresHoverEvents(void * jarg1) {
40019   unsigned int jresult ;
40020   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
40021   bool result;
40022
40023   arg1 = (Dali::CustomActorImpl *)jarg1;
40024   {
40025     try {
40026       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresHoverEvents();
40027     } catch (std::out_of_range& e) {
40028       {
40029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40030       };
40031     } catch (std::exception& e) {
40032       {
40033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40034       };
40035     } catch (Dali::DaliException e) {
40036       {
40037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40038       };
40039     } catch (...) {
40040       {
40041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40042       };
40043     }
40044   }
40045
40046   jresult = result;
40047   return jresult;
40048 }
40049
40050
40051 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresWheelEvents(void * jarg1) {
40052   unsigned int jresult ;
40053   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
40054   bool result;
40055
40056   arg1 = (Dali::CustomActorImpl *)jarg1;
40057   {
40058     try {
40059       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresWheelEvents();
40060     } catch (std::out_of_range& e) {
40061       {
40062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40063       };
40064     } catch (std::exception& e) {
40065       {
40066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40067       };
40068     } catch (Dali::DaliException e) {
40069       {
40070         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40071       };
40072     } catch (...) {
40073       {
40074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40075       };
40076     }
40077   }
40078
40079   jresult = result;
40080   return jresult;
40081 }
40082
40083
40084 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_IsRelayoutEnabled(void * jarg1) {
40085   unsigned int jresult ;
40086   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
40087   bool result;
40088
40089   arg1 = (Dali::CustomActorImpl *)jarg1;
40090   {
40091     try {
40092       result = (bool)((Dali::CustomActorImpl const *)arg1)->IsRelayoutEnabled();
40093     } catch (std::out_of_range& e) {
40094       {
40095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40096       };
40097     } catch (std::exception& e) {
40098       {
40099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40100       };
40101     } catch (Dali::DaliException e) {
40102       {
40103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40104       };
40105     } catch (...) {
40106       {
40107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40108       };
40109     }
40110   }
40111
40112   jresult = result;
40113   return jresult;
40114 }
40115
40116
40117 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_0() {
40118   void * jresult ;
40119   Dali::CustomActor *result = 0 ;
40120
40121   {
40122     try {
40123       result = (Dali::CustomActor *)new Dali::CustomActor();
40124     } catch (std::out_of_range& e) {
40125       {
40126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40127       };
40128     } catch (std::exception& e) {
40129       {
40130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40131       };
40132     } catch (Dali::DaliException e) {
40133       {
40134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40135       };
40136     } catch (...) {
40137       {
40138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40139       };
40140     }
40141   }
40142
40143   jresult = (void *)result;
40144   return jresult;
40145 }
40146
40147
40148 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_DownCast(void * jarg1) {
40149   void * jresult ;
40150   Dali::BaseHandle arg1 ;
40151   Dali::BaseHandle *argp1 ;
40152   Dali::CustomActor result;
40153
40154   argp1 = (Dali::BaseHandle *)jarg1;
40155   if (!argp1) {
40156     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40157     return 0;
40158   }
40159   arg1 = *argp1;
40160   {
40161     try {
40162       result = Dali::CustomActor::DownCast(arg1);
40163     } catch (std::out_of_range& e) {
40164       {
40165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40166       };
40167     } catch (std::exception& e) {
40168       {
40169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40170       };
40171     } catch (Dali::DaliException e) {
40172       {
40173         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40174       };
40175     } catch (...) {
40176       {
40177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40178       };
40179     }
40180   }
40181
40182   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
40183   return jresult;
40184 }
40185
40186
40187 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomActor(void * jarg1) {
40188   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
40189
40190   arg1 = (Dali::CustomActor *)jarg1;
40191   {
40192     try {
40193       delete arg1;
40194     } catch (std::out_of_range& e) {
40195       {
40196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40197       };
40198     } catch (std::exception& e) {
40199       {
40200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40201       };
40202     } catch (Dali::DaliException e) {
40203       {
40204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40205       };
40206     } catch (...) {
40207       {
40208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40209       };
40210     }
40211   }
40212
40213 }
40214
40215
40216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_GetImplementation(void * jarg1) {
40217   void * jresult ;
40218   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
40219   Dali::CustomActorImpl *result = 0 ;
40220
40221   arg1 = (Dali::CustomActor *)jarg1;
40222   {
40223     try {
40224       result = (Dali::CustomActorImpl *) &((Dali::CustomActor const *)arg1)->GetImplementation();
40225     } catch (std::out_of_range& e) {
40226       {
40227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40228       };
40229     } catch (std::exception& e) {
40230       {
40231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40232       };
40233     } catch (Dali::DaliException e) {
40234       {
40235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40236       };
40237     } catch (...) {
40238       {
40239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40240       };
40241     }
40242   }
40243
40244   jresult = (void *)result;
40245   return jresult;
40246 }
40247
40248
40249 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_1(void * jarg1) {
40250   void * jresult ;
40251   Dali::CustomActorImpl *arg1 = 0 ;
40252   Dali::CustomActor *result = 0 ;
40253
40254   arg1 = (Dali::CustomActorImpl *)jarg1;
40255   if (!arg1) {
40256     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActorImpl & type is null", 0);
40257     return 0;
40258   }
40259   {
40260     try {
40261       result = (Dali::CustomActor *)new Dali::CustomActor(*arg1);
40262     } catch (std::out_of_range& e) {
40263       {
40264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40265       };
40266     } catch (std::exception& e) {
40267       {
40268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40269       };
40270     } catch (Dali::DaliException e) {
40271       {
40272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40273       };
40274     } catch (...) {
40275       {
40276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40277       };
40278     }
40279   }
40280
40281   jresult = (void *)result;
40282   return jresult;
40283 }
40284
40285
40286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_2(void * jarg1) {
40287   void * jresult ;
40288   Dali::CustomActor *arg1 = 0 ;
40289   Dali::CustomActor *result = 0 ;
40290
40291   arg1 = (Dali::CustomActor *)jarg1;
40292   if (!arg1) {
40293     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
40294     return 0;
40295   }
40296   {
40297     try {
40298       result = (Dali::CustomActor *)new Dali::CustomActor((Dali::CustomActor const &)*arg1);
40299     } catch (std::out_of_range& e) {
40300       {
40301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40302       };
40303     } catch (std::exception& e) {
40304       {
40305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40306       };
40307     } catch (Dali::DaliException e) {
40308       {
40309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40310       };
40311     } catch (...) {
40312       {
40313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40314       };
40315     }
40316   }
40317
40318   jresult = (void *)result;
40319   return jresult;
40320 }
40321
40322
40323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_Assign(void * jarg1, void * jarg2) {
40324   void * jresult ;
40325   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
40326   Dali::CustomActor *arg2 = 0 ;
40327   Dali::CustomActor *result = 0 ;
40328
40329   arg1 = (Dali::CustomActor *)jarg1;
40330   arg2 = (Dali::CustomActor *)jarg2;
40331   if (!arg2) {
40332     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
40333     return 0;
40334   }
40335   {
40336     try {
40337       result = (Dali::CustomActor *) &(arg1)->operator =((Dali::CustomActor const &)*arg2);
40338     } catch (std::out_of_range& e) {
40339       {
40340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40341       };
40342     } catch (std::exception& e) {
40343       {
40344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40345       };
40346     } catch (Dali::DaliException e) {
40347       {
40348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40349       };
40350     } catch (...) {
40351       {
40352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40353       };
40354     }
40355   }
40356
40357   jresult = (void *)result;
40358   return jresult;
40359 }
40360
40361
40362 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_POSITION_get() {
40363   int jresult ;
40364   int result;
40365
40366   result = (int)Dali::PanGestureDetector::Property::SCREEN_POSITION;
40367   jresult = (int)result;
40368   return jresult;
40369 }
40370
40371
40372 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_DISPLACEMENT_get() {
40373   int jresult ;
40374   int result;
40375
40376   result = (int)Dali::PanGestureDetector::Property::SCREEN_DISPLACEMENT;
40377   jresult = (int)result;
40378   return jresult;
40379 }
40380
40381
40382 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_VELOCITY_get() {
40383   int jresult ;
40384   int result;
40385
40386   result = (int)Dali::PanGestureDetector::Property::SCREEN_VELOCITY;
40387   jresult = (int)result;
40388   return jresult;
40389 }
40390
40391
40392 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_POSITION_get() {
40393   int jresult ;
40394   int result;
40395
40396   result = (int)Dali::PanGestureDetector::Property::LOCAL_POSITION;
40397   jresult = (int)result;
40398   return jresult;
40399 }
40400
40401
40402 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_DISPLACEMENT_get() {
40403   int jresult ;
40404   int result;
40405
40406   result = (int)Dali::PanGestureDetector::Property::LOCAL_DISPLACEMENT;
40407   jresult = (int)result;
40408   return jresult;
40409 }
40410
40411
40412 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_VELOCITY_get() {
40413   int jresult ;
40414   int result;
40415
40416   result = (int)Dali::PanGestureDetector::Property::LOCAL_VELOCITY;
40417   jresult = (int)result;
40418   return jresult;
40419 }
40420
40421
40422 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_PANNING_get() {
40423   int jresult ;
40424   int result;
40425
40426   result = (int)Dali::PanGestureDetector::Property::PANNING;
40427   jresult = (int)result;
40428   return jresult;
40429 }
40430
40431
40432 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector_Property() {
40433   void * jresult ;
40434   Dali::PanGestureDetector::Property *result = 0 ;
40435
40436   {
40437     try {
40438       result = (Dali::PanGestureDetector::Property *)new Dali::PanGestureDetector::Property();
40439     } catch (std::out_of_range& e) {
40440       {
40441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40442       };
40443     } catch (std::exception& e) {
40444       {
40445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40446       };
40447     } catch (Dali::DaliException e) {
40448       {
40449         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40450       };
40451     } catch (...) {
40452       {
40453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40454       };
40455     }
40456   }
40457
40458   jresult = (void *)result;
40459   return jresult;
40460 }
40461
40462
40463 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector_Property(void * jarg1) {
40464   Dali::PanGestureDetector::Property *arg1 = (Dali::PanGestureDetector::Property *) 0 ;
40465
40466   arg1 = (Dali::PanGestureDetector::Property *)jarg1;
40467   {
40468     try {
40469       delete arg1;
40470     } catch (std::out_of_range& e) {
40471       {
40472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40473       };
40474     } catch (std::exception& e) {
40475       {
40476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40477       };
40478     } catch (Dali::DaliException e) {
40479       {
40480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40481       };
40482     } catch (...) {
40483       {
40484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40485       };
40486     }
40487   }
40488
40489 }
40490
40491
40492 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_LEFT_get() {
40493   void * jresult ;
40494   Dali::Radian *result = 0 ;
40495
40496   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_LEFT;
40497   jresult = (void *)result;
40498   return jresult;
40499 }
40500
40501
40502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_RIGHT_get() {
40503   void * jresult ;
40504   Dali::Radian *result = 0 ;
40505
40506   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_RIGHT;
40507   jresult = (void *)result;
40508   return jresult;
40509 }
40510
40511
40512 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_UP_get() {
40513   void * jresult ;
40514   Dali::Radian *result = 0 ;
40515
40516   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_UP;
40517   jresult = (void *)result;
40518   return jresult;
40519 }
40520
40521
40522 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_DOWN_get() {
40523   void * jresult ;
40524   Dali::Radian *result = 0 ;
40525
40526   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_DOWN;
40527   jresult = (void *)result;
40528   return jresult;
40529 }
40530
40531
40532 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_HORIZONTAL_get() {
40533   void * jresult ;
40534   Dali::Radian *result = 0 ;
40535
40536   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_HORIZONTAL;
40537   jresult = (void *)result;
40538   return jresult;
40539 }
40540
40541
40542 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_VERTICAL_get() {
40543   void * jresult ;
40544   Dali::Radian *result = 0 ;
40545
40546   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_VERTICAL;
40547   jresult = (void *)result;
40548   return jresult;
40549 }
40550
40551
40552 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DEFAULT_THRESHOLD_get() {
40553   void * jresult ;
40554   Dali::Radian *result = 0 ;
40555
40556   result = (Dali::Radian *)&Dali::PanGestureDetector::DEFAULT_THRESHOLD;
40557   jresult = (void *)result;
40558   return jresult;
40559 }
40560
40561
40562 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_0() {
40563   void * jresult ;
40564   Dali::PanGestureDetector *result = 0 ;
40565
40566   {
40567     try {
40568       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector();
40569     } catch (std::out_of_range& e) {
40570       {
40571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40572       };
40573     } catch (std::exception& e) {
40574       {
40575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40576       };
40577     } catch (Dali::DaliException e) {
40578       {
40579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40580       };
40581     } catch (...) {
40582       {
40583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40584       };
40585     }
40586   }
40587
40588   jresult = (void *)result;
40589   return jresult;
40590 }
40591
40592
40593 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_New() {
40594   void * jresult ;
40595   Dali::PanGestureDetector result;
40596
40597   {
40598     try {
40599       result = Dali::PanGestureDetector::New();
40600     } catch (std::out_of_range& e) {
40601       {
40602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40603       };
40604     } catch (std::exception& e) {
40605       {
40606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40607       };
40608     } catch (Dali::DaliException e) {
40609       {
40610         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40611       };
40612     } catch (...) {
40613       {
40614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40615       };
40616     }
40617   }
40618
40619   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
40620   return jresult;
40621 }
40622
40623
40624 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DownCast(void * jarg1) {
40625   void * jresult ;
40626   Dali::BaseHandle arg1 ;
40627   Dali::BaseHandle *argp1 ;
40628   Dali::PanGestureDetector result;
40629
40630   argp1 = (Dali::BaseHandle *)jarg1;
40631   if (!argp1) {
40632     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40633     return 0;
40634   }
40635   arg1 = *argp1;
40636   {
40637     try {
40638       result = Dali::PanGestureDetector::DownCast(arg1);
40639     } catch (std::out_of_range& e) {
40640       {
40641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40642       };
40643     } catch (std::exception& e) {
40644       {
40645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40646       };
40647     } catch (Dali::DaliException e) {
40648       {
40649         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40650       };
40651     } catch (...) {
40652       {
40653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40654       };
40655     }
40656   }
40657
40658   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
40659   return jresult;
40660 }
40661
40662
40663 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector(void * jarg1) {
40664   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40665
40666   arg1 = (Dali::PanGestureDetector *)jarg1;
40667   {
40668     try {
40669       delete arg1;
40670     } catch (std::out_of_range& e) {
40671       {
40672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40673       };
40674     } catch (std::exception& e) {
40675       {
40676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40677       };
40678     } catch (Dali::DaliException e) {
40679       {
40680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40681       };
40682     } catch (...) {
40683       {
40684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40685       };
40686     }
40687   }
40688
40689 }
40690
40691
40692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_1(void * jarg1) {
40693   void * jresult ;
40694   Dali::PanGestureDetector *arg1 = 0 ;
40695   Dali::PanGestureDetector *result = 0 ;
40696
40697   arg1 = (Dali::PanGestureDetector *)jarg1;
40698   if (!arg1) {
40699     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
40700     return 0;
40701   }
40702   {
40703     try {
40704       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector((Dali::PanGestureDetector const &)*arg1);
40705     } catch (std::out_of_range& e) {
40706       {
40707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40708       };
40709     } catch (std::exception& e) {
40710       {
40711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40712       };
40713     } catch (Dali::DaliException e) {
40714       {
40715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40716       };
40717     } catch (...) {
40718       {
40719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40720       };
40721     }
40722   }
40723
40724   jresult = (void *)result;
40725   return jresult;
40726 }
40727
40728
40729 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_Assign(void * jarg1, void * jarg2) {
40730   void * jresult ;
40731   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40732   Dali::PanGestureDetector *arg2 = 0 ;
40733   Dali::PanGestureDetector *result = 0 ;
40734
40735   arg1 = (Dali::PanGestureDetector *)jarg1;
40736   arg2 = (Dali::PanGestureDetector *)jarg2;
40737   if (!arg2) {
40738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
40739     return 0;
40740   }
40741   {
40742     try {
40743       result = (Dali::PanGestureDetector *) &(arg1)->operator =((Dali::PanGestureDetector const &)*arg2);
40744     } catch (std::out_of_range& e) {
40745       {
40746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40747       };
40748     } catch (std::exception& e) {
40749       {
40750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40751       };
40752     } catch (Dali::DaliException e) {
40753       {
40754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40755       };
40756     } catch (...) {
40757       {
40758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40759       };
40760     }
40761   }
40762
40763   jresult = (void *)result;
40764   return jresult;
40765 }
40766
40767
40768 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMinimumTouchesRequired(void * jarg1, unsigned int jarg2) {
40769   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40770   unsigned int arg2 ;
40771
40772   arg1 = (Dali::PanGestureDetector *)jarg1;
40773   arg2 = (unsigned int)jarg2;
40774   {
40775     try {
40776       (arg1)->SetMinimumTouchesRequired(arg2);
40777     } catch (std::out_of_range& e) {
40778       {
40779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40780       };
40781     } catch (std::exception& e) {
40782       {
40783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40784       };
40785     } catch (Dali::DaliException e) {
40786       {
40787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40788       };
40789     } catch (...) {
40790       {
40791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40792       };
40793     }
40794   }
40795
40796 }
40797
40798
40799 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMaximumTouchesRequired(void * jarg1, unsigned int jarg2) {
40800   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40801   unsigned int arg2 ;
40802
40803   arg1 = (Dali::PanGestureDetector *)jarg1;
40804   arg2 = (unsigned int)jarg2;
40805   {
40806     try {
40807       (arg1)->SetMaximumTouchesRequired(arg2);
40808     } catch (std::out_of_range& e) {
40809       {
40810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40811       };
40812     } catch (std::exception& e) {
40813       {
40814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40815       };
40816     } catch (Dali::DaliException e) {
40817       {
40818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40819       };
40820     } catch (...) {
40821       {
40822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40823       };
40824     }
40825   }
40826
40827 }
40828
40829
40830 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
40831   unsigned int jresult ;
40832   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40833   unsigned int result;
40834
40835   arg1 = (Dali::PanGestureDetector *)jarg1;
40836   {
40837     try {
40838       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMinimumTouchesRequired();
40839     } catch (std::out_of_range& e) {
40840       {
40841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40842       };
40843     } catch (std::exception& e) {
40844       {
40845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40846       };
40847     } catch (Dali::DaliException e) {
40848       {
40849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40850       };
40851     } catch (...) {
40852       {
40853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40854       };
40855     }
40856   }
40857
40858   jresult = result;
40859   return jresult;
40860 }
40861
40862
40863 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
40864   unsigned int jresult ;
40865   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40866   unsigned int result;
40867
40868   arg1 = (Dali::PanGestureDetector *)jarg1;
40869   {
40870     try {
40871       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMaximumTouchesRequired();
40872     } catch (std::out_of_range& e) {
40873       {
40874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40875       };
40876     } catch (std::exception& e) {
40877       {
40878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40879       };
40880     } catch (Dali::DaliException e) {
40881       {
40882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40883       };
40884     } catch (...) {
40885       {
40886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40887       };
40888     }
40889   }
40890
40891   jresult = result;
40892   return jresult;
40893 }
40894
40895
40896 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
40897   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40898   Dali::Radian arg2 ;
40899   Dali::Radian arg3 ;
40900   Dali::Radian *argp2 ;
40901   Dali::Radian *argp3 ;
40902
40903   arg1 = (Dali::PanGestureDetector *)jarg1;
40904   argp2 = (Dali::Radian *)jarg2;
40905   if (!argp2) {
40906     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40907     return ;
40908   }
40909   arg2 = *argp2;
40910   argp3 = (Dali::Radian *)jarg3;
40911   if (!argp3) {
40912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40913     return ;
40914   }
40915   arg3 = *argp3;
40916   {
40917     try {
40918       (arg1)->AddAngle(arg2,arg3);
40919     } catch (std::out_of_range& e) {
40920       {
40921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40922       };
40923     } catch (std::exception& e) {
40924       {
40925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40926       };
40927     } catch (Dali::DaliException e) {
40928       {
40929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40930       };
40931     } catch (...) {
40932       {
40933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40934       };
40935     }
40936   }
40937
40938 }
40939
40940
40941 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_1(void * jarg1, void * jarg2) {
40942   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40943   Dali::Radian arg2 ;
40944   Dali::Radian *argp2 ;
40945
40946   arg1 = (Dali::PanGestureDetector *)jarg1;
40947   argp2 = (Dali::Radian *)jarg2;
40948   if (!argp2) {
40949     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40950     return ;
40951   }
40952   arg2 = *argp2;
40953   {
40954     try {
40955       (arg1)->AddAngle(arg2);
40956     } catch (std::out_of_range& e) {
40957       {
40958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40959       };
40960     } catch (std::exception& e) {
40961       {
40962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40963       };
40964     } catch (Dali::DaliException e) {
40965       {
40966         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40967       };
40968     } catch (...) {
40969       {
40970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40971       };
40972     }
40973   }
40974
40975 }
40976
40977
40978 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
40979   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40980   Dali::Radian arg2 ;
40981   Dali::Radian arg3 ;
40982   Dali::Radian *argp2 ;
40983   Dali::Radian *argp3 ;
40984
40985   arg1 = (Dali::PanGestureDetector *)jarg1;
40986   argp2 = (Dali::Radian *)jarg2;
40987   if (!argp2) {
40988     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40989     return ;
40990   }
40991   arg2 = *argp2;
40992   argp3 = (Dali::Radian *)jarg3;
40993   if (!argp3) {
40994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40995     return ;
40996   }
40997   arg3 = *argp3;
40998   {
40999     try {
41000       (arg1)->AddDirection(arg2,arg3);
41001     } catch (std::out_of_range& e) {
41002       {
41003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41004       };
41005     } catch (std::exception& e) {
41006       {
41007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41008       };
41009     } catch (Dali::DaliException e) {
41010       {
41011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41012       };
41013     } catch (...) {
41014       {
41015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41016       };
41017     }
41018   }
41019
41020 }
41021
41022
41023 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_1(void * jarg1, void * jarg2) {
41024   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41025   Dali::Radian arg2 ;
41026   Dali::Radian *argp2 ;
41027
41028   arg1 = (Dali::PanGestureDetector *)jarg1;
41029   argp2 = (Dali::Radian *)jarg2;
41030   if (!argp2) {
41031     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41032     return ;
41033   }
41034   arg2 = *argp2;
41035   {
41036     try {
41037       (arg1)->AddDirection(arg2);
41038     } catch (std::out_of_range& e) {
41039       {
41040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41041       };
41042     } catch (std::exception& e) {
41043       {
41044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41045       };
41046     } catch (Dali::DaliException e) {
41047       {
41048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41049       };
41050     } catch (...) {
41051       {
41052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41053       };
41054     }
41055   }
41056
41057 }
41058
41059
41060 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngleCount(void * jarg1) {
41061   unsigned long jresult ;
41062   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41063   size_t result;
41064
41065   arg1 = (Dali::PanGestureDetector *)jarg1;
41066   {
41067     try {
41068       result = ((Dali::PanGestureDetector const *)arg1)->GetAngleCount();
41069     } catch (std::out_of_range& e) {
41070       {
41071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41072       };
41073     } catch (std::exception& e) {
41074       {
41075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41076       };
41077     } catch (Dali::DaliException e) {
41078       {
41079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41080       };
41081     } catch (...) {
41082       {
41083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41084       };
41085     }
41086   }
41087
41088   jresult = (unsigned long)result;
41089   return jresult;
41090 }
41091
41092
41093 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngle(void * jarg1, unsigned long jarg2) {
41094   void * jresult ;
41095   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41096   size_t arg2 ;
41097   Dali::PanGestureDetector::AngleThresholdPair result;
41098
41099   arg1 = (Dali::PanGestureDetector *)jarg1;
41100   arg2 = (size_t)jarg2;
41101   {
41102     try {
41103       result = ((Dali::PanGestureDetector const *)arg1)->GetAngle(arg2);
41104     } catch (std::out_of_range& e) {
41105       {
41106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41107       };
41108     } catch (std::exception& e) {
41109       {
41110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41111       };
41112     } catch (Dali::DaliException e) {
41113       {
41114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41115       };
41116     } catch (...) {
41117       {
41118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41119       };
41120     }
41121   }
41122
41123   jresult = new Dali::PanGestureDetector::AngleThresholdPair((const Dali::PanGestureDetector::AngleThresholdPair &)result);
41124   return jresult;
41125 }
41126
41127
41128 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_ClearAngles(void * jarg1) {
41129   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41130
41131   arg1 = (Dali::PanGestureDetector *)jarg1;
41132   {
41133     try {
41134       (arg1)->ClearAngles();
41135     } catch (std::out_of_range& e) {
41136       {
41137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41138       };
41139     } catch (std::exception& e) {
41140       {
41141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41142       };
41143     } catch (Dali::DaliException e) {
41144       {
41145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41146       };
41147     } catch (...) {
41148       {
41149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41150       };
41151     }
41152   }
41153
41154 }
41155
41156
41157 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveAngle(void * jarg1, void * jarg2) {
41158   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41159   Dali::Radian arg2 ;
41160   Dali::Radian *argp2 ;
41161
41162   arg1 = (Dali::PanGestureDetector *)jarg1;
41163   argp2 = (Dali::Radian *)jarg2;
41164   if (!argp2) {
41165     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41166     return ;
41167   }
41168   arg2 = *argp2;
41169   {
41170     try {
41171       (arg1)->RemoveAngle(arg2);
41172     } catch (std::out_of_range& e) {
41173       {
41174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41175       };
41176     } catch (std::exception& e) {
41177       {
41178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41179       };
41180     } catch (Dali::DaliException e) {
41181       {
41182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41183       };
41184     } catch (...) {
41185       {
41186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41187       };
41188     }
41189   }
41190
41191 }
41192
41193
41194 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveDirection(void * jarg1, void * jarg2) {
41195   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41196   Dali::Radian arg2 ;
41197   Dali::Radian *argp2 ;
41198
41199   arg1 = (Dali::PanGestureDetector *)jarg1;
41200   argp2 = (Dali::Radian *)jarg2;
41201   if (!argp2) {
41202     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41203     return ;
41204   }
41205   arg2 = *argp2;
41206   {
41207     try {
41208       (arg1)->RemoveDirection(arg2);
41209     } catch (std::out_of_range& e) {
41210       {
41211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41212       };
41213     } catch (std::exception& e) {
41214       {
41215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41216       };
41217     } catch (Dali::DaliException e) {
41218       {
41219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41220       };
41221     } catch (...) {
41222       {
41223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41224       };
41225     }
41226   }
41227
41228 }
41229
41230
41231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DetectedSignal(void * jarg1) {
41232   void * jresult ;
41233   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41234   Dali::PanGestureDetector::DetectedSignalType *result = 0 ;
41235
41236   arg1 = (Dali::PanGestureDetector *)jarg1;
41237   {
41238     try {
41239       result = (Dali::PanGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
41240     } catch (std::out_of_range& e) {
41241       {
41242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41243       };
41244     } catch (std::exception& e) {
41245       {
41246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41247       };
41248     } catch (Dali::DaliException e) {
41249       {
41250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41251       };
41252     } catch (...) {
41253       {
41254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41255       };
41256     }
41257   }
41258
41259   jresult = (void *)result;
41260   return jresult;
41261 }
41262
41263
41264 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetPanGestureProperties(void * jarg1) {
41265   Dali::PanGesture *arg1 = 0 ;
41266
41267   arg1 = (Dali::PanGesture *)jarg1;
41268   if (!arg1) {
41269     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
41270     return ;
41271   }
41272   {
41273     try {
41274       Dali::PanGestureDetector::SetPanGestureProperties((Dali::PanGesture const &)*arg1);
41275     } catch (std::out_of_range& e) {
41276       {
41277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41278       };
41279     } catch (std::exception& e) {
41280       {
41281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41282       };
41283     } catch (Dali::DaliException e) {
41284       {
41285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41286       };
41287     } catch (...) {
41288       {
41289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41290       };
41291     }
41292   }
41293
41294 }
41295
41296
41297 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_0() {
41298   void * jresult ;
41299   Dali::PanGesture *result = 0 ;
41300
41301   {
41302     try {
41303       result = (Dali::PanGesture *)new Dali::PanGesture();
41304     } catch (std::out_of_range& e) {
41305       {
41306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41307       };
41308     } catch (std::exception& e) {
41309       {
41310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41311       };
41312     } catch (Dali::DaliException e) {
41313       {
41314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41315       };
41316     } catch (...) {
41317       {
41318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41319       };
41320     }
41321   }
41322
41323   jresult = (void *)result;
41324   return jresult;
41325 }
41326
41327
41328 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_1(int jarg1) {
41329   void * jresult ;
41330   Dali::Gesture::State arg1 ;
41331   Dali::PanGesture *result = 0 ;
41332
41333   arg1 = (Dali::Gesture::State)jarg1;
41334   {
41335     try {
41336       result = (Dali::PanGesture *)new Dali::PanGesture(arg1);
41337     } catch (std::out_of_range& e) {
41338       {
41339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41340       };
41341     } catch (std::exception& e) {
41342       {
41343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41344       };
41345     } catch (Dali::DaliException e) {
41346       {
41347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41348       };
41349     } catch (...) {
41350       {
41351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41352       };
41353     }
41354   }
41355
41356   jresult = (void *)result;
41357   return jresult;
41358 }
41359
41360
41361 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_2(void * jarg1) {
41362   void * jresult ;
41363   Dali::PanGesture *arg1 = 0 ;
41364   Dali::PanGesture *result = 0 ;
41365
41366   arg1 = (Dali::PanGesture *)jarg1;
41367   if (!arg1) {
41368     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
41369     return 0;
41370   }
41371   {
41372     try {
41373       result = (Dali::PanGesture *)new Dali::PanGesture((Dali::PanGesture const &)*arg1);
41374     } catch (std::out_of_range& e) {
41375       {
41376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41377       };
41378     } catch (std::exception& e) {
41379       {
41380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41381       };
41382     } catch (Dali::DaliException e) {
41383       {
41384         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41385       };
41386     } catch (...) {
41387       {
41388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41389       };
41390     }
41391   }
41392
41393   jresult = (void *)result;
41394   return jresult;
41395 }
41396
41397
41398 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_Assign(void * jarg1, void * jarg2) {
41399   void * jresult ;
41400   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41401   Dali::PanGesture *arg2 = 0 ;
41402   Dali::PanGesture *result = 0 ;
41403
41404   arg1 = (Dali::PanGesture *)jarg1;
41405   arg2 = (Dali::PanGesture *)jarg2;
41406   if (!arg2) {
41407     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
41408     return 0;
41409   }
41410   {
41411     try {
41412       result = (Dali::PanGesture *) &(arg1)->operator =((Dali::PanGesture const &)*arg2);
41413     } catch (std::out_of_range& e) {
41414       {
41415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41416       };
41417     } catch (std::exception& e) {
41418       {
41419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41420       };
41421     } catch (Dali::DaliException e) {
41422       {
41423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41424       };
41425     } catch (...) {
41426       {
41427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41428       };
41429     }
41430   }
41431
41432   jresult = (void *)result;
41433   return jresult;
41434 }
41435
41436
41437 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGesture(void * jarg1) {
41438   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41439
41440   arg1 = (Dali::PanGesture *)jarg1;
41441   {
41442     try {
41443       delete arg1;
41444     } catch (std::out_of_range& e) {
41445       {
41446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41447       };
41448     } catch (std::exception& e) {
41449       {
41450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41451       };
41452     } catch (Dali::DaliException e) {
41453       {
41454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41455       };
41456     } catch (...) {
41457       {
41458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41459       };
41460     }
41461   }
41462
41463 }
41464
41465
41466 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_velocity_set(void * jarg1, void * jarg2) {
41467   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41468   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41469
41470   arg1 = (Dali::PanGesture *)jarg1;
41471   arg2 = (Dali::Vector2 *)jarg2;
41472   if (arg1) (arg1)->velocity = *arg2;
41473 }
41474
41475
41476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_velocity_get(void * jarg1) {
41477   void * jresult ;
41478   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41479   Dali::Vector2 *result = 0 ;
41480
41481   arg1 = (Dali::PanGesture *)jarg1;
41482   result = (Dali::Vector2 *)& ((arg1)->velocity);
41483   jresult = (void *)result;
41484   return jresult;
41485 }
41486
41487
41488 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_displacement_set(void * jarg1, void * jarg2) {
41489   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41490   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41491
41492   arg1 = (Dali::PanGesture *)jarg1;
41493   arg2 = (Dali::Vector2 *)jarg2;
41494   if (arg1) (arg1)->displacement = *arg2;
41495 }
41496
41497
41498 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_displacement_get(void * jarg1) {
41499   void * jresult ;
41500   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41501   Dali::Vector2 *result = 0 ;
41502
41503   arg1 = (Dali::PanGesture *)jarg1;
41504   result = (Dali::Vector2 *)& ((arg1)->displacement);
41505   jresult = (void *)result;
41506   return jresult;
41507 }
41508
41509
41510 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_position_set(void * jarg1, void * jarg2) {
41511   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41512   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41513
41514   arg1 = (Dali::PanGesture *)jarg1;
41515   arg2 = (Dali::Vector2 *)jarg2;
41516   if (arg1) (arg1)->position = *arg2;
41517 }
41518
41519
41520 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_position_get(void * jarg1) {
41521   void * jresult ;
41522   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41523   Dali::Vector2 *result = 0 ;
41524
41525   arg1 = (Dali::PanGesture *)jarg1;
41526   result = (Dali::Vector2 *)& ((arg1)->position);
41527   jresult = (void *)result;
41528   return jresult;
41529 }
41530
41531
41532 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_set(void * jarg1, void * jarg2) {
41533   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41534   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41535
41536   arg1 = (Dali::PanGesture *)jarg1;
41537   arg2 = (Dali::Vector2 *)jarg2;
41538   if (arg1) (arg1)->screenVelocity = *arg2;
41539 }
41540
41541
41542 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_get(void * jarg1) {
41543   void * jresult ;
41544   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41545   Dali::Vector2 *result = 0 ;
41546
41547   arg1 = (Dali::PanGesture *)jarg1;
41548   result = (Dali::Vector2 *)& ((arg1)->screenVelocity);
41549   jresult = (void *)result;
41550   return jresult;
41551 }
41552
41553
41554 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_set(void * jarg1, void * jarg2) {
41555   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41556   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41557
41558   arg1 = (Dali::PanGesture *)jarg1;
41559   arg2 = (Dali::Vector2 *)jarg2;
41560   if (arg1) (arg1)->screenDisplacement = *arg2;
41561 }
41562
41563
41564 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_get(void * jarg1) {
41565   void * jresult ;
41566   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41567   Dali::Vector2 *result = 0 ;
41568
41569   arg1 = (Dali::PanGesture *)jarg1;
41570   result = (Dali::Vector2 *)& ((arg1)->screenDisplacement);
41571   jresult = (void *)result;
41572   return jresult;
41573 }
41574
41575
41576 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_set(void * jarg1, void * jarg2) {
41577   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41578   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41579
41580   arg1 = (Dali::PanGesture *)jarg1;
41581   arg2 = (Dali::Vector2 *)jarg2;
41582   if (arg1) (arg1)->screenPosition = *arg2;
41583 }
41584
41585
41586 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_get(void * jarg1) {
41587   void * jresult ;
41588   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41589   Dali::Vector2 *result = 0 ;
41590
41591   arg1 = (Dali::PanGesture *)jarg1;
41592   result = (Dali::Vector2 *)& ((arg1)->screenPosition);
41593   jresult = (void *)result;
41594   return jresult;
41595 }
41596
41597
41598 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
41599   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41600   unsigned int arg2 ;
41601
41602   arg1 = (Dali::PanGesture *)jarg1;
41603   arg2 = (unsigned int)jarg2;
41604   if (arg1) (arg1)->numberOfTouches = arg2;
41605 }
41606
41607
41608 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_get(void * jarg1) {
41609   unsigned int jresult ;
41610   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41611   unsigned int result;
41612
41613   arg1 = (Dali::PanGesture *)jarg1;
41614   result = (unsigned int) ((arg1)->numberOfTouches);
41615   jresult = result;
41616   return jresult;
41617 }
41618
41619
41620 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetSpeed(void * jarg1) {
41621   float jresult ;
41622   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41623   float result;
41624
41625   arg1 = (Dali::PanGesture *)jarg1;
41626   {
41627     try {
41628       result = (float)((Dali::PanGesture const *)arg1)->GetSpeed();
41629     } catch (std::out_of_range& e) {
41630       {
41631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41632       };
41633     } catch (std::exception& e) {
41634       {
41635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41636       };
41637     } catch (Dali::DaliException e) {
41638       {
41639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41640       };
41641     } catch (...) {
41642       {
41643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41644       };
41645     }
41646   }
41647
41648   jresult = result;
41649   return jresult;
41650 }
41651
41652
41653 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetDistance(void * jarg1) {
41654   float jresult ;
41655   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41656   float result;
41657
41658   arg1 = (Dali::PanGesture *)jarg1;
41659   {
41660     try {
41661       result = (float)((Dali::PanGesture const *)arg1)->GetDistance();
41662     } catch (std::out_of_range& e) {
41663       {
41664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41665       };
41666     } catch (std::exception& e) {
41667       {
41668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41669       };
41670     } catch (Dali::DaliException e) {
41671       {
41672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41673       };
41674     } catch (...) {
41675       {
41676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41677       };
41678     }
41679   }
41680
41681   jresult = result;
41682   return jresult;
41683 }
41684
41685
41686 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenSpeed(void * jarg1) {
41687   float jresult ;
41688   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41689   float result;
41690
41691   arg1 = (Dali::PanGesture *)jarg1;
41692   {
41693     try {
41694       result = (float)((Dali::PanGesture const *)arg1)->GetScreenSpeed();
41695     } catch (std::out_of_range& e) {
41696       {
41697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41698       };
41699     } catch (std::exception& e) {
41700       {
41701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41702       };
41703     } catch (Dali::DaliException e) {
41704       {
41705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41706       };
41707     } catch (...) {
41708       {
41709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41710       };
41711     }
41712   }
41713
41714   jresult = result;
41715   return jresult;
41716 }
41717
41718
41719 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenDistance(void * jarg1) {
41720   float jresult ;
41721   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41722   float result;
41723
41724   arg1 = (Dali::PanGesture *)jarg1;
41725   {
41726     try {
41727       result = (float)((Dali::PanGesture const *)arg1)->GetScreenDistance();
41728     } catch (std::out_of_range& e) {
41729       {
41730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41731       };
41732     } catch (std::exception& e) {
41733       {
41734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41735       };
41736     } catch (Dali::DaliException e) {
41737       {
41738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41739       };
41740     } catch (...) {
41741       {
41742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41743       };
41744     }
41745   }
41746
41747   jresult = result;
41748   return jresult;
41749 }
41750
41751
41752 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_0() {
41753   void * jresult ;
41754   Dali::PinchGestureDetector *result = 0 ;
41755
41756   {
41757     try {
41758       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector();
41759     } catch (std::out_of_range& e) {
41760       {
41761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41762       };
41763     } catch (std::exception& e) {
41764       {
41765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41766       };
41767     } catch (Dali::DaliException e) {
41768       {
41769         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41770       };
41771     } catch (...) {
41772       {
41773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41774       };
41775     }
41776   }
41777
41778   jresult = (void *)result;
41779   return jresult;
41780 }
41781
41782
41783 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_New() {
41784   void * jresult ;
41785   Dali::PinchGestureDetector result;
41786
41787   {
41788     try {
41789       result = Dali::PinchGestureDetector::New();
41790     } catch (std::out_of_range& e) {
41791       {
41792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41793       };
41794     } catch (std::exception& e) {
41795       {
41796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41797       };
41798     } catch (Dali::DaliException e) {
41799       {
41800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41801       };
41802     } catch (...) {
41803       {
41804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41805       };
41806     }
41807   }
41808
41809   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
41810   return jresult;
41811 }
41812
41813
41814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DownCast(void * jarg1) {
41815   void * jresult ;
41816   Dali::BaseHandle arg1 ;
41817   Dali::BaseHandle *argp1 ;
41818   Dali::PinchGestureDetector result;
41819
41820   argp1 = (Dali::BaseHandle *)jarg1;
41821   if (!argp1) {
41822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41823     return 0;
41824   }
41825   arg1 = *argp1;
41826   {
41827     try {
41828       result = Dali::PinchGestureDetector::DownCast(arg1);
41829     } catch (std::out_of_range& e) {
41830       {
41831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41832       };
41833     } catch (std::exception& e) {
41834       {
41835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41836       };
41837     } catch (Dali::DaliException e) {
41838       {
41839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41840       };
41841     } catch (...) {
41842       {
41843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41844       };
41845     }
41846   }
41847
41848   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
41849   return jresult;
41850 }
41851
41852
41853 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetector(void * jarg1) {
41854   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41855
41856   arg1 = (Dali::PinchGestureDetector *)jarg1;
41857   {
41858     try {
41859       delete arg1;
41860     } catch (std::out_of_range& e) {
41861       {
41862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41863       };
41864     } catch (std::exception& e) {
41865       {
41866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41867       };
41868     } catch (Dali::DaliException e) {
41869       {
41870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41871       };
41872     } catch (...) {
41873       {
41874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41875       };
41876     }
41877   }
41878
41879 }
41880
41881
41882 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_1(void * jarg1) {
41883   void * jresult ;
41884   Dali::PinchGestureDetector *arg1 = 0 ;
41885   Dali::PinchGestureDetector *result = 0 ;
41886
41887   arg1 = (Dali::PinchGestureDetector *)jarg1;
41888   if (!arg1) {
41889     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
41890     return 0;
41891   }
41892   {
41893     try {
41894       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector((Dali::PinchGestureDetector const &)*arg1);
41895     } catch (std::out_of_range& e) {
41896       {
41897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41898       };
41899     } catch (std::exception& e) {
41900       {
41901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41902       };
41903     } catch (Dali::DaliException e) {
41904       {
41905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41906       };
41907     } catch (...) {
41908       {
41909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41910       };
41911     }
41912   }
41913
41914   jresult = (void *)result;
41915   return jresult;
41916 }
41917
41918
41919 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_Assign(void * jarg1, void * jarg2) {
41920   void * jresult ;
41921   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41922   Dali::PinchGestureDetector *arg2 = 0 ;
41923   Dali::PinchGestureDetector *result = 0 ;
41924
41925   arg1 = (Dali::PinchGestureDetector *)jarg1;
41926   arg2 = (Dali::PinchGestureDetector *)jarg2;
41927   if (!arg2) {
41928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
41929     return 0;
41930   }
41931   {
41932     try {
41933       result = (Dali::PinchGestureDetector *) &(arg1)->operator =((Dali::PinchGestureDetector const &)*arg2);
41934     } catch (std::out_of_range& e) {
41935       {
41936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41937       };
41938     } catch (std::exception& e) {
41939       {
41940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41941       };
41942     } catch (Dali::DaliException e) {
41943       {
41944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41945       };
41946     } catch (...) {
41947       {
41948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41949       };
41950     }
41951   }
41952
41953   jresult = (void *)result;
41954   return jresult;
41955 }
41956
41957
41958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DetectedSignal(void * jarg1) {
41959   void * jresult ;
41960   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41961   Dali::PinchGestureDetector::DetectedSignalType *result = 0 ;
41962
41963   arg1 = (Dali::PinchGestureDetector *)jarg1;
41964   {
41965     try {
41966       result = (Dali::PinchGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
41967     } catch (std::out_of_range& e) {
41968       {
41969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41970       };
41971     } catch (std::exception& e) {
41972       {
41973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41974       };
41975     } catch (Dali::DaliException e) {
41976       {
41977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41978       };
41979     } catch (...) {
41980       {
41981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41982       };
41983     }
41984   }
41985
41986   jresult = (void *)result;
41987   return jresult;
41988 }
41989
41990
41991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_0(int jarg1) {
41992   void * jresult ;
41993   Dali::Gesture::State arg1 ;
41994   Dali::PinchGesture *result = 0 ;
41995
41996   arg1 = (Dali::Gesture::State)jarg1;
41997   {
41998     try {
41999       result = (Dali::PinchGesture *)new Dali::PinchGesture(arg1);
42000     } catch (std::out_of_range& e) {
42001       {
42002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42003       };
42004     } catch (std::exception& e) {
42005       {
42006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42007       };
42008     } catch (Dali::DaliException e) {
42009       {
42010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42011       };
42012     } catch (...) {
42013       {
42014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42015       };
42016     }
42017   }
42018
42019   jresult = (void *)result;
42020   return jresult;
42021 }
42022
42023
42024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_1(void * jarg1) {
42025   void * jresult ;
42026   Dali::PinchGesture *arg1 = 0 ;
42027   Dali::PinchGesture *result = 0 ;
42028
42029   arg1 = (Dali::PinchGesture *)jarg1;
42030   if (!arg1) {
42031     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
42032     return 0;
42033   }
42034   {
42035     try {
42036       result = (Dali::PinchGesture *)new Dali::PinchGesture((Dali::PinchGesture const &)*arg1);
42037     } catch (std::out_of_range& e) {
42038       {
42039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42040       };
42041     } catch (std::exception& e) {
42042       {
42043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42044       };
42045     } catch (Dali::DaliException e) {
42046       {
42047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42048       };
42049     } catch (...) {
42050       {
42051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42052       };
42053     }
42054   }
42055
42056   jresult = (void *)result;
42057   return jresult;
42058 }
42059
42060
42061 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_Assign(void * jarg1, void * jarg2) {
42062   void * jresult ;
42063   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42064   Dali::PinchGesture *arg2 = 0 ;
42065   Dali::PinchGesture *result = 0 ;
42066
42067   arg1 = (Dali::PinchGesture *)jarg1;
42068   arg2 = (Dali::PinchGesture *)jarg2;
42069   if (!arg2) {
42070     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
42071     return 0;
42072   }
42073   {
42074     try {
42075       result = (Dali::PinchGesture *) &(arg1)->operator =((Dali::PinchGesture const &)*arg2);
42076     } catch (std::out_of_range& e) {
42077       {
42078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42079       };
42080     } catch (std::exception& e) {
42081       {
42082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42083       };
42084     } catch (Dali::DaliException e) {
42085       {
42086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42087       };
42088     } catch (...) {
42089       {
42090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42091       };
42092     }
42093   }
42094
42095   jresult = (void *)result;
42096   return jresult;
42097 }
42098
42099
42100 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGesture(void * jarg1) {
42101   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42102
42103   arg1 = (Dali::PinchGesture *)jarg1;
42104   {
42105     try {
42106       delete arg1;
42107     } catch (std::out_of_range& e) {
42108       {
42109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42110       };
42111     } catch (std::exception& e) {
42112       {
42113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42114       };
42115     } catch (Dali::DaliException e) {
42116       {
42117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42118       };
42119     } catch (...) {
42120       {
42121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42122       };
42123     }
42124   }
42125
42126 }
42127
42128
42129 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_scale_set(void * jarg1, float jarg2) {
42130   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42131   float arg2 ;
42132
42133   arg1 = (Dali::PinchGesture *)jarg1;
42134   arg2 = (float)jarg2;
42135   if (arg1) (arg1)->scale = arg2;
42136 }
42137
42138
42139 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_scale_get(void * jarg1) {
42140   float jresult ;
42141   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42142   float result;
42143
42144   arg1 = (Dali::PinchGesture *)jarg1;
42145   result = (float) ((arg1)->scale);
42146   jresult = result;
42147   return jresult;
42148 }
42149
42150
42151 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_speed_set(void * jarg1, float jarg2) {
42152   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42153   float arg2 ;
42154
42155   arg1 = (Dali::PinchGesture *)jarg1;
42156   arg2 = (float)jarg2;
42157   if (arg1) (arg1)->speed = arg2;
42158 }
42159
42160
42161 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_speed_get(void * jarg1) {
42162   float jresult ;
42163   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42164   float result;
42165
42166   arg1 = (Dali::PinchGesture *)jarg1;
42167   result = (float) ((arg1)->speed);
42168   jresult = result;
42169   return jresult;
42170 }
42171
42172
42173 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_set(void * jarg1, void * jarg2) {
42174   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42175   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42176
42177   arg1 = (Dali::PinchGesture *)jarg1;
42178   arg2 = (Dali::Vector2 *)jarg2;
42179   if (arg1) (arg1)->screenCenterPoint = *arg2;
42180 }
42181
42182
42183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_get(void * jarg1) {
42184   void * jresult ;
42185   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42186   Dali::Vector2 *result = 0 ;
42187
42188   arg1 = (Dali::PinchGesture *)jarg1;
42189   result = (Dali::Vector2 *)& ((arg1)->screenCenterPoint);
42190   jresult = (void *)result;
42191   return jresult;
42192 }
42193
42194
42195 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_set(void * jarg1, void * jarg2) {
42196   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42197   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42198
42199   arg1 = (Dali::PinchGesture *)jarg1;
42200   arg2 = (Dali::Vector2 *)jarg2;
42201   if (arg1) (arg1)->localCenterPoint = *arg2;
42202 }
42203
42204
42205 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_get(void * jarg1) {
42206   void * jresult ;
42207   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42208   Dali::Vector2 *result = 0 ;
42209
42210   arg1 = (Dali::PinchGesture *)jarg1;
42211   result = (Dali::Vector2 *)& ((arg1)->localCenterPoint);
42212   jresult = (void *)result;
42213   return jresult;
42214 }
42215
42216
42217 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_0() {
42218   void * jresult ;
42219   Dali::TapGestureDetector *result = 0 ;
42220
42221   {
42222     try {
42223       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector();
42224     } catch (std::out_of_range& e) {
42225       {
42226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42227       };
42228     } catch (std::exception& e) {
42229       {
42230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42231       };
42232     } catch (Dali::DaliException e) {
42233       {
42234         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42235       };
42236     } catch (...) {
42237       {
42238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42239       };
42240     }
42241   }
42242
42243   jresult = (void *)result;
42244   return jresult;
42245 }
42246
42247
42248 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_0() {
42249   void * jresult ;
42250   Dali::TapGestureDetector result;
42251
42252   {
42253     try {
42254       result = Dali::TapGestureDetector::New();
42255     } catch (std::out_of_range& e) {
42256       {
42257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42258       };
42259     } catch (std::exception& e) {
42260       {
42261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42262       };
42263     } catch (Dali::DaliException e) {
42264       {
42265         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42266       };
42267     } catch (...) {
42268       {
42269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42270       };
42271     }
42272   }
42273
42274   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
42275   return jresult;
42276 }
42277
42278
42279 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_1(unsigned int jarg1) {
42280   void * jresult ;
42281   unsigned int arg1 ;
42282   Dali::TapGestureDetector result;
42283
42284   arg1 = (unsigned int)jarg1;
42285   {
42286     try {
42287       result = Dali::TapGestureDetector::New(arg1);
42288     } catch (std::out_of_range& e) {
42289       {
42290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42291       };
42292     } catch (std::exception& e) {
42293       {
42294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42295       };
42296     } catch (Dali::DaliException e) {
42297       {
42298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42299       };
42300     } catch (...) {
42301       {
42302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42303       };
42304     }
42305   }
42306
42307   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
42308   return jresult;
42309 }
42310
42311
42312 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DownCast(void * jarg1) {
42313   void * jresult ;
42314   Dali::BaseHandle arg1 ;
42315   Dali::BaseHandle *argp1 ;
42316   Dali::TapGestureDetector result;
42317
42318   argp1 = (Dali::BaseHandle *)jarg1;
42319   if (!argp1) {
42320     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42321     return 0;
42322   }
42323   arg1 = *argp1;
42324   {
42325     try {
42326       result = Dali::TapGestureDetector::DownCast(arg1);
42327     } catch (std::out_of_range& e) {
42328       {
42329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42330       };
42331     } catch (std::exception& e) {
42332       {
42333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42334       };
42335     } catch (Dali::DaliException e) {
42336       {
42337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42338       };
42339     } catch (...) {
42340       {
42341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42342       };
42343     }
42344   }
42345
42346   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
42347   return jresult;
42348 }
42349
42350
42351 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetector(void * jarg1) {
42352   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42353
42354   arg1 = (Dali::TapGestureDetector *)jarg1;
42355   {
42356     try {
42357       delete arg1;
42358     } catch (std::out_of_range& e) {
42359       {
42360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42361       };
42362     } catch (std::exception& e) {
42363       {
42364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42365       };
42366     } catch (Dali::DaliException e) {
42367       {
42368         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42369       };
42370     } catch (...) {
42371       {
42372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42373       };
42374     }
42375   }
42376
42377 }
42378
42379
42380 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_1(void * jarg1) {
42381   void * jresult ;
42382   Dali::TapGestureDetector *arg1 = 0 ;
42383   Dali::TapGestureDetector *result = 0 ;
42384
42385   arg1 = (Dali::TapGestureDetector *)jarg1;
42386   if (!arg1) {
42387     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
42388     return 0;
42389   }
42390   {
42391     try {
42392       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector((Dali::TapGestureDetector const &)*arg1);
42393     } catch (std::out_of_range& e) {
42394       {
42395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42396       };
42397     } catch (std::exception& e) {
42398       {
42399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42400       };
42401     } catch (Dali::DaliException e) {
42402       {
42403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42404       };
42405     } catch (...) {
42406       {
42407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42408       };
42409     }
42410   }
42411
42412   jresult = (void *)result;
42413   return jresult;
42414 }
42415
42416
42417 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_Assign(void * jarg1, void * jarg2) {
42418   void * jresult ;
42419   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42420   Dali::TapGestureDetector *arg2 = 0 ;
42421   Dali::TapGestureDetector *result = 0 ;
42422
42423   arg1 = (Dali::TapGestureDetector *)jarg1;
42424   arg2 = (Dali::TapGestureDetector *)jarg2;
42425   if (!arg2) {
42426     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
42427     return 0;
42428   }
42429   {
42430     try {
42431       result = (Dali::TapGestureDetector *) &(arg1)->operator =((Dali::TapGestureDetector const &)*arg2);
42432     } catch (std::out_of_range& e) {
42433       {
42434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42435       };
42436     } catch (std::exception& e) {
42437       {
42438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42439       };
42440     } catch (Dali::DaliException e) {
42441       {
42442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42443       };
42444     } catch (...) {
42445       {
42446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42447       };
42448     }
42449   }
42450
42451   jresult = (void *)result;
42452   return jresult;
42453 }
42454
42455
42456 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMinimumTapsRequired(void * jarg1, unsigned int jarg2) {
42457   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42458   unsigned int arg2 ;
42459
42460   arg1 = (Dali::TapGestureDetector *)jarg1;
42461   arg2 = (unsigned int)jarg2;
42462   {
42463     try {
42464       (arg1)->SetMinimumTapsRequired(arg2);
42465     } catch (std::out_of_range& e) {
42466       {
42467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42468       };
42469     } catch (std::exception& e) {
42470       {
42471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42472       };
42473     } catch (Dali::DaliException e) {
42474       {
42475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42476       };
42477     } catch (...) {
42478       {
42479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42480       };
42481     }
42482   }
42483
42484 }
42485
42486
42487 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMaximumTapsRequired(void * jarg1, unsigned int jarg2) {
42488   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42489   unsigned int arg2 ;
42490
42491   arg1 = (Dali::TapGestureDetector *)jarg1;
42492   arg2 = (unsigned int)jarg2;
42493   {
42494     try {
42495       (arg1)->SetMaximumTapsRequired(arg2);
42496     } catch (std::out_of_range& e) {
42497       {
42498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42499       };
42500     } catch (std::exception& e) {
42501       {
42502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42503       };
42504     } catch (Dali::DaliException e) {
42505       {
42506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42507       };
42508     } catch (...) {
42509       {
42510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42511       };
42512     }
42513   }
42514
42515 }
42516
42517
42518 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMinimumTapsRequired(void * jarg1) {
42519   unsigned int jresult ;
42520   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42521   unsigned int result;
42522
42523   arg1 = (Dali::TapGestureDetector *)jarg1;
42524   {
42525     try {
42526       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMinimumTapsRequired();
42527     } catch (std::out_of_range& e) {
42528       {
42529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42530       };
42531     } catch (std::exception& e) {
42532       {
42533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42534       };
42535     } catch (Dali::DaliException e) {
42536       {
42537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42538       };
42539     } catch (...) {
42540       {
42541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42542       };
42543     }
42544   }
42545
42546   jresult = result;
42547   return jresult;
42548 }
42549
42550
42551 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMaximumTapsRequired(void * jarg1) {
42552   unsigned int jresult ;
42553   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42554   unsigned int result;
42555
42556   arg1 = (Dali::TapGestureDetector *)jarg1;
42557   {
42558     try {
42559       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMaximumTapsRequired();
42560     } catch (std::out_of_range& e) {
42561       {
42562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42563       };
42564     } catch (std::exception& e) {
42565       {
42566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42567       };
42568     } catch (Dali::DaliException e) {
42569       {
42570         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42571       };
42572     } catch (...) {
42573       {
42574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42575       };
42576     }
42577   }
42578
42579   jresult = result;
42580   return jresult;
42581 }
42582
42583
42584 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DetectedSignal(void * jarg1) {
42585   void * jresult ;
42586   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42587   Dali::TapGestureDetector::DetectedSignalType *result = 0 ;
42588
42589   arg1 = (Dali::TapGestureDetector *)jarg1;
42590   {
42591     try {
42592       result = (Dali::TapGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
42593     } catch (std::out_of_range& e) {
42594       {
42595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42596       };
42597     } catch (std::exception& e) {
42598       {
42599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42600       };
42601     } catch (Dali::DaliException e) {
42602       {
42603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42604       };
42605     } catch (...) {
42606       {
42607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42608       };
42609     }
42610   }
42611
42612   jresult = (void *)result;
42613   return jresult;
42614 }
42615
42616
42617 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_0() {
42618   void * jresult ;
42619   Dali::TapGesture *result = 0 ;
42620
42621   {
42622     try {
42623       result = (Dali::TapGesture *)new Dali::TapGesture();
42624     } catch (std::out_of_range& e) {
42625       {
42626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42627       };
42628     } catch (std::exception& e) {
42629       {
42630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42631       };
42632     } catch (Dali::DaliException e) {
42633       {
42634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42635       };
42636     } catch (...) {
42637       {
42638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42639       };
42640     }
42641   }
42642
42643   jresult = (void *)result;
42644   return jresult;
42645 }
42646
42647
42648 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_1(void * jarg1) {
42649   void * jresult ;
42650   Dali::TapGesture *arg1 = 0 ;
42651   Dali::TapGesture *result = 0 ;
42652
42653   arg1 = (Dali::TapGesture *)jarg1;
42654   if (!arg1) {
42655     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
42656     return 0;
42657   }
42658   {
42659     try {
42660       result = (Dali::TapGesture *)new Dali::TapGesture((Dali::TapGesture const &)*arg1);
42661     } catch (std::out_of_range& e) {
42662       {
42663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42664       };
42665     } catch (std::exception& e) {
42666       {
42667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42668       };
42669     } catch (Dali::DaliException e) {
42670       {
42671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42672       };
42673     } catch (...) {
42674       {
42675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42676       };
42677     }
42678   }
42679
42680   jresult = (void *)result;
42681   return jresult;
42682 }
42683
42684
42685 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_Assign(void * jarg1, void * jarg2) {
42686   void * jresult ;
42687   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42688   Dali::TapGesture *arg2 = 0 ;
42689   Dali::TapGesture *result = 0 ;
42690
42691   arg1 = (Dali::TapGesture *)jarg1;
42692   arg2 = (Dali::TapGesture *)jarg2;
42693   if (!arg2) {
42694     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
42695     return 0;
42696   }
42697   {
42698     try {
42699       result = (Dali::TapGesture *) &(arg1)->operator =((Dali::TapGesture const &)*arg2);
42700     } catch (std::out_of_range& e) {
42701       {
42702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42703       };
42704     } catch (std::exception& e) {
42705       {
42706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42707       };
42708     } catch (Dali::DaliException e) {
42709       {
42710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42711       };
42712     } catch (...) {
42713       {
42714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42715       };
42716     }
42717   }
42718
42719   jresult = (void *)result;
42720   return jresult;
42721 }
42722
42723
42724 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGesture(void * jarg1) {
42725   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42726
42727   arg1 = (Dali::TapGesture *)jarg1;
42728   {
42729     try {
42730       delete arg1;
42731     } catch (std::out_of_range& e) {
42732       {
42733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42734       };
42735     } catch (std::exception& e) {
42736       {
42737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42738       };
42739     } catch (Dali::DaliException e) {
42740       {
42741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42742       };
42743     } catch (...) {
42744       {
42745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42746       };
42747     }
42748   }
42749
42750 }
42751
42752
42753 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_set(void * jarg1, unsigned int jarg2) {
42754   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42755   unsigned int arg2 ;
42756
42757   arg1 = (Dali::TapGesture *)jarg1;
42758   arg2 = (unsigned int)jarg2;
42759   if (arg1) (arg1)->numberOfTaps = arg2;
42760 }
42761
42762
42763 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_get(void * jarg1) {
42764   unsigned int jresult ;
42765   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42766   unsigned int result;
42767
42768   arg1 = (Dali::TapGesture *)jarg1;
42769   result = (unsigned int) ((arg1)->numberOfTaps);
42770   jresult = result;
42771   return jresult;
42772 }
42773
42774
42775 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
42776   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42777   unsigned int arg2 ;
42778
42779   arg1 = (Dali::TapGesture *)jarg1;
42780   arg2 = (unsigned int)jarg2;
42781   if (arg1) (arg1)->numberOfTouches = arg2;
42782 }
42783
42784
42785 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_get(void * jarg1) {
42786   unsigned int jresult ;
42787   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42788   unsigned int result;
42789
42790   arg1 = (Dali::TapGesture *)jarg1;
42791   result = (unsigned int) ((arg1)->numberOfTouches);
42792   jresult = result;
42793   return jresult;
42794 }
42795
42796
42797 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_set(void * jarg1, void * jarg2) {
42798   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42799   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42800
42801   arg1 = (Dali::TapGesture *)jarg1;
42802   arg2 = (Dali::Vector2 *)jarg2;
42803   if (arg1) (arg1)->screenPoint = *arg2;
42804 }
42805
42806
42807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_get(void * jarg1) {
42808   void * jresult ;
42809   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42810   Dali::Vector2 *result = 0 ;
42811
42812   arg1 = (Dali::TapGesture *)jarg1;
42813   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
42814   jresult = (void *)result;
42815   return jresult;
42816 }
42817
42818
42819 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_set(void * jarg1, void * jarg2) {
42820   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42821   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42822
42823   arg1 = (Dali::TapGesture *)jarg1;
42824   arg2 = (Dali::Vector2 *)jarg2;
42825   if (arg1) (arg1)->localPoint = *arg2;
42826 }
42827
42828
42829 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_get(void * jarg1) {
42830   void * jresult ;
42831   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42832   Dali::Vector2 *result = 0 ;
42833
42834   arg1 = (Dali::TapGesture *)jarg1;
42835   result = (Dali::Vector2 *)& ((arg1)->localPoint);
42836   jresult = (void *)result;
42837   return jresult;
42838 }
42839
42840
42841 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_0() {
42842   void * jresult ;
42843   Dali::AlphaFunction *result = 0 ;
42844
42845   {
42846     try {
42847       result = (Dali::AlphaFunction *)new Dali::AlphaFunction();
42848     } catch (std::out_of_range& e) {
42849       {
42850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42851       };
42852     } catch (std::exception& e) {
42853       {
42854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42855       };
42856     } catch (Dali::DaliException e) {
42857       {
42858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42859       };
42860     } catch (...) {
42861       {
42862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42863       };
42864     }
42865   }
42866
42867   jresult = (void *)result;
42868   return jresult;
42869 }
42870
42871
42872 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_1(int jarg1) {
42873   void * jresult ;
42874   Dali::AlphaFunction::BuiltinFunction arg1 ;
42875   Dali::AlphaFunction *result = 0 ;
42876
42877   arg1 = (Dali::AlphaFunction::BuiltinFunction)jarg1;
42878   {
42879     try {
42880       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
42881     } catch (std::out_of_range& e) {
42882       {
42883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42884       };
42885     } catch (std::exception& e) {
42886       {
42887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42888       };
42889     } catch (Dali::DaliException e) {
42890       {
42891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42892       };
42893     } catch (...) {
42894       {
42895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42896       };
42897     }
42898   }
42899
42900   jresult = (void *)result;
42901   return jresult;
42902 }
42903
42904
42905 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_2(void * jarg1) {
42906   void * jresult ;
42907   Dali::AlphaFunctionPrototype arg1 = (Dali::AlphaFunctionPrototype) 0 ;
42908   Dali::AlphaFunction *result = 0 ;
42909
42910   arg1 = (Dali::AlphaFunctionPrototype)jarg1;
42911   {
42912     try {
42913       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
42914     } catch (std::out_of_range& e) {
42915       {
42916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42917       };
42918     } catch (std::exception& e) {
42919       {
42920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42921       };
42922     } catch (Dali::DaliException e) {
42923       {
42924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42925       };
42926     } catch (...) {
42927       {
42928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42929       };
42930     }
42931   }
42932
42933   jresult = (void *)result;
42934   return jresult;
42935 }
42936
42937
42938 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_3(void * jarg1, void * jarg2) {
42939   void * jresult ;
42940   Dali::Vector2 *arg1 = 0 ;
42941   Dali::Vector2 *arg2 = 0 ;
42942   Dali::AlphaFunction *result = 0 ;
42943
42944   arg1 = (Dali::Vector2 *)jarg1;
42945   if (!arg1) {
42946     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
42947     return 0;
42948   }
42949   arg2 = (Dali::Vector2 *)jarg2;
42950   if (!arg2) {
42951     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
42952     return 0;
42953   }
42954   {
42955     try {
42956       result = (Dali::AlphaFunction *)new Dali::AlphaFunction((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
42957     } catch (std::out_of_range& e) {
42958       {
42959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42960       };
42961     } catch (std::exception& e) {
42962       {
42963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42964       };
42965     } catch (Dali::DaliException e) {
42966       {
42967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42968       };
42969     } catch (...) {
42970       {
42971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42972       };
42973     }
42974   }
42975
42976   jresult = (void *)result;
42977   return jresult;
42978 }
42979
42980
42981 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBezierControlPoints(void * jarg1) {
42982   void * jresult ;
42983   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42984   Dali::Vector4 result;
42985
42986   arg1 = (Dali::AlphaFunction *)jarg1;
42987   {
42988     try {
42989       result = ((Dali::AlphaFunction const *)arg1)->GetBezierControlPoints();
42990     } catch (std::out_of_range& e) {
42991       {
42992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42993       };
42994     } catch (std::exception& e) {
42995       {
42996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42997       };
42998     } catch (Dali::DaliException e) {
42999       {
43000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43001       };
43002     } catch (...) {
43003       {
43004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43005       };
43006     }
43007   }
43008
43009   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
43010   return jresult;
43011 }
43012
43013
43014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetCustomFunction(void * jarg1) {
43015   void * jresult ;
43016   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43017   Dali::AlphaFunctionPrototype result;
43018
43019   arg1 = (Dali::AlphaFunction *)jarg1;
43020   {
43021     try {
43022       result = (Dali::AlphaFunctionPrototype)((Dali::AlphaFunction const *)arg1)->GetCustomFunction();
43023     } catch (std::out_of_range& e) {
43024       {
43025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43026       };
43027     } catch (std::exception& e) {
43028       {
43029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43030       };
43031     } catch (Dali::DaliException e) {
43032       {
43033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43034       };
43035     } catch (...) {
43036       {
43037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43038       };
43039     }
43040   }
43041
43042   jresult = (void *)result;
43043   return jresult;
43044 }
43045
43046
43047 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBuiltinFunction(void * jarg1) {
43048   int jresult ;
43049   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43050   Dali::AlphaFunction::BuiltinFunction result;
43051
43052   arg1 = (Dali::AlphaFunction *)jarg1;
43053   {
43054     try {
43055       result = (Dali::AlphaFunction::BuiltinFunction)((Dali::AlphaFunction const *)arg1)->GetBuiltinFunction();
43056     } catch (std::out_of_range& e) {
43057       {
43058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43059       };
43060     } catch (std::exception& e) {
43061       {
43062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43063       };
43064     } catch (Dali::DaliException e) {
43065       {
43066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43067       };
43068     } catch (...) {
43069       {
43070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43071       };
43072     }
43073   }
43074
43075   jresult = (int)result;
43076   return jresult;
43077 }
43078
43079
43080 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetMode(void * jarg1) {
43081   int jresult ;
43082   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43083   Dali::AlphaFunction::Mode result;
43084
43085   arg1 = (Dali::AlphaFunction *)jarg1;
43086   {
43087     try {
43088       result = (Dali::AlphaFunction::Mode)((Dali::AlphaFunction const *)arg1)->GetMode();
43089     } catch (std::out_of_range& e) {
43090       {
43091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43092       };
43093     } catch (std::exception& e) {
43094       {
43095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43096       };
43097     } catch (Dali::DaliException e) {
43098       {
43099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43100       };
43101     } catch (...) {
43102       {
43103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43104       };
43105     }
43106   }
43107
43108   jresult = (int)result;
43109   return jresult;
43110 }
43111
43112
43113 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AlphaFunction(void * jarg1) {
43114   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43115
43116   arg1 = (Dali::AlphaFunction *)jarg1;
43117   {
43118     try {
43119       delete arg1;
43120     } catch (std::out_of_range& e) {
43121       {
43122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43123       };
43124     } catch (std::exception& e) {
43125       {
43126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43127       };
43128     } catch (Dali::DaliException e) {
43129       {
43130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43131       };
43132     } catch (...) {
43133       {
43134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43135       };
43136     }
43137   }
43138
43139 }
43140
43141
43142 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_New() {
43143   void * jresult ;
43144   Dali::KeyFrames result;
43145
43146   {
43147     try {
43148       result = Dali::KeyFrames::New();
43149     } catch (std::out_of_range& e) {
43150       {
43151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43152       };
43153     } catch (std::exception& e) {
43154       {
43155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43156       };
43157     } catch (Dali::DaliException e) {
43158       {
43159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43160       };
43161     } catch (...) {
43162       {
43163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43164       };
43165     }
43166   }
43167
43168   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
43169   return jresult;
43170 }
43171
43172
43173 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_DownCast(void * jarg1) {
43174   void * jresult ;
43175   Dali::BaseHandle arg1 ;
43176   Dali::BaseHandle *argp1 ;
43177   Dali::KeyFrames result;
43178
43179   argp1 = (Dali::BaseHandle *)jarg1;
43180   if (!argp1) {
43181     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43182     return 0;
43183   }
43184   arg1 = *argp1;
43185   {
43186     try {
43187       result = Dali::KeyFrames::DownCast(arg1);
43188     } catch (std::out_of_range& e) {
43189       {
43190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43191       };
43192     } catch (std::exception& e) {
43193       {
43194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43195       };
43196     } catch (Dali::DaliException e) {
43197       {
43198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43199       };
43200     } catch (...) {
43201       {
43202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43203       };
43204     }
43205   }
43206
43207   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
43208   return jresult;
43209 }
43210
43211
43212 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_0() {
43213   void * jresult ;
43214   Dali::KeyFrames *result = 0 ;
43215
43216   {
43217     try {
43218       result = (Dali::KeyFrames *)new Dali::KeyFrames();
43219     } catch (std::out_of_range& e) {
43220       {
43221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43222       };
43223     } catch (std::exception& e) {
43224       {
43225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43226       };
43227     } catch (Dali::DaliException e) {
43228       {
43229         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43230       };
43231     } catch (...) {
43232       {
43233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43234       };
43235     }
43236   }
43237
43238   jresult = (void *)result;
43239   return jresult;
43240 }
43241
43242
43243 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyFrames(void * jarg1) {
43244   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43245
43246   arg1 = (Dali::KeyFrames *)jarg1;
43247   {
43248     try {
43249       delete arg1;
43250     } catch (std::out_of_range& e) {
43251       {
43252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43253       };
43254     } catch (std::exception& e) {
43255       {
43256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43257       };
43258     } catch (Dali::DaliException e) {
43259       {
43260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43261       };
43262     } catch (...) {
43263       {
43264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43265       };
43266     }
43267   }
43268
43269 }
43270
43271
43272 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_1(void * jarg1) {
43273   void * jresult ;
43274   Dali::KeyFrames *arg1 = 0 ;
43275   Dali::KeyFrames *result = 0 ;
43276
43277   arg1 = (Dali::KeyFrames *)jarg1;
43278   if (!arg1) {
43279     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
43280     return 0;
43281   }
43282   {
43283     try {
43284       result = (Dali::KeyFrames *)new Dali::KeyFrames((Dali::KeyFrames const &)*arg1);
43285     } catch (std::out_of_range& e) {
43286       {
43287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43288       };
43289     } catch (std::exception& e) {
43290       {
43291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43292       };
43293     } catch (Dali::DaliException e) {
43294       {
43295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43296       };
43297     } catch (...) {
43298       {
43299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43300       };
43301     }
43302   }
43303
43304   jresult = (void *)result;
43305   return jresult;
43306 }
43307
43308
43309 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_Assign(void * jarg1, void * jarg2) {
43310   void * jresult ;
43311   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43312   Dali::KeyFrames *arg2 = 0 ;
43313   Dali::KeyFrames *result = 0 ;
43314
43315   arg1 = (Dali::KeyFrames *)jarg1;
43316   arg2 = (Dali::KeyFrames *)jarg2;
43317   if (!arg2) {
43318     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
43319     return 0;
43320   }
43321   {
43322     try {
43323       result = (Dali::KeyFrames *) &(arg1)->operator =((Dali::KeyFrames const &)*arg2);
43324     } catch (std::out_of_range& e) {
43325       {
43326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43327       };
43328     } catch (std::exception& e) {
43329       {
43330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43331       };
43332     } catch (Dali::DaliException e) {
43333       {
43334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43335       };
43336     } catch (...) {
43337       {
43338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43339       };
43340     }
43341   }
43342
43343   jresult = (void *)result;
43344   return jresult;
43345 }
43346
43347
43348 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_KeyFrames_GetType(void * jarg1) {
43349   int jresult ;
43350   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43351   Dali::Property::Type result;
43352
43353   arg1 = (Dali::KeyFrames *)jarg1;
43354   {
43355     try {
43356       result = (Dali::Property::Type)((Dali::KeyFrames const *)arg1)->GetType();
43357     } catch (std::out_of_range& e) {
43358       {
43359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43360       };
43361     } catch (std::exception& e) {
43362       {
43363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43364       };
43365     } catch (Dali::DaliException e) {
43366       {
43367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43368       };
43369     } catch (...) {
43370       {
43371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43372       };
43373     }
43374   }
43375
43376   jresult = (int)result;
43377   return jresult;
43378 }
43379
43380
43381 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_0(void * jarg1, float jarg2, void * jarg3) {
43382   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43383   float arg2 ;
43384   Dali::Property::Value arg3 ;
43385   Dali::Property::Value *argp3 ;
43386
43387   arg1 = (Dali::KeyFrames *)jarg1;
43388   arg2 = (float)jarg2;
43389   argp3 = (Dali::Property::Value *)jarg3;
43390   if (!argp3) {
43391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
43392     return ;
43393   }
43394   arg3 = *argp3;
43395   {
43396     try {
43397       (arg1)->Add(arg2,arg3);
43398     } catch (std::out_of_range& e) {
43399       {
43400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43401       };
43402     } catch (std::exception& e) {
43403       {
43404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43405       };
43406     } catch (Dali::DaliException e) {
43407       {
43408         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43409       };
43410     } catch (...) {
43411       {
43412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43413       };
43414     }
43415   }
43416
43417 }
43418
43419
43420 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_1(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
43421   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43422   float arg2 ;
43423   Dali::Property::Value arg3 ;
43424   Dali::AlphaFunction arg4 ;
43425   Dali::Property::Value *argp3 ;
43426   Dali::AlphaFunction *argp4 ;
43427
43428   arg1 = (Dali::KeyFrames *)jarg1;
43429   arg2 = (float)jarg2;
43430   argp3 = (Dali::Property::Value *)jarg3;
43431   if (!argp3) {
43432     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
43433     return ;
43434   }
43435   arg3 = *argp3;
43436   argp4 = (Dali::AlphaFunction *)jarg4;
43437   if (!argp4) {
43438     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
43439     return ;
43440   }
43441   arg4 = *argp4;
43442   {
43443     try {
43444       (arg1)->Add(arg2,arg3,arg4);
43445     } catch (std::out_of_range& e) {
43446       {
43447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43448       };
43449     } catch (std::exception& e) {
43450       {
43451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43452       };
43453     } catch (Dali::DaliException e) {
43454       {
43455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43456       };
43457     } catch (...) {
43458       {
43459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43460       };
43461     }
43462   }
43463
43464 }
43465
43466
43467 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_POINTS_get() {
43468   int jresult ;
43469   int result;
43470
43471   result = (int)Dali::Path::Property::POINTS;
43472   jresult = (int)result;
43473   return jresult;
43474 }
43475
43476
43477 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_CONTROL_POINTS_get() {
43478   int jresult ;
43479   int result;
43480
43481   result = (int)Dali::Path::Property::CONTROL_POINTS;
43482   jresult = (int)result;
43483   return jresult;
43484 }
43485
43486
43487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path_Property() {
43488   void * jresult ;
43489   Dali::Path::Property *result = 0 ;
43490
43491   {
43492     try {
43493       result = (Dali::Path::Property *)new Dali::Path::Property();
43494     } catch (std::out_of_range& e) {
43495       {
43496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43497       };
43498     } catch (std::exception& e) {
43499       {
43500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43501       };
43502     } catch (Dali::DaliException e) {
43503       {
43504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43505       };
43506     } catch (...) {
43507       {
43508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43509       };
43510     }
43511   }
43512
43513   jresult = (void *)result;
43514   return jresult;
43515 }
43516
43517
43518 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path_Property(void * jarg1) {
43519   Dali::Path::Property *arg1 = (Dali::Path::Property *) 0 ;
43520
43521   arg1 = (Dali::Path::Property *)jarg1;
43522   {
43523     try {
43524       delete arg1;
43525     } catch (std::out_of_range& e) {
43526       {
43527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43528       };
43529     } catch (std::exception& e) {
43530       {
43531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43532       };
43533     } catch (Dali::DaliException e) {
43534       {
43535         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43536       };
43537     } catch (...) {
43538       {
43539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43540       };
43541     }
43542   }
43543
43544 }
43545
43546
43547 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_New() {
43548   void * jresult ;
43549   Dali::Path result;
43550
43551   {
43552     try {
43553       result = Dali::Path::New();
43554     } catch (std::out_of_range& e) {
43555       {
43556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43557       };
43558     } catch (std::exception& e) {
43559       {
43560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43561       };
43562     } catch (Dali::DaliException e) {
43563       {
43564         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43565       };
43566     } catch (...) {
43567       {
43568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43569       };
43570     }
43571   }
43572
43573   jresult = new Dali::Path((const Dali::Path &)result);
43574   return jresult;
43575 }
43576
43577
43578 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_DownCast(void * jarg1) {
43579   void * jresult ;
43580   Dali::BaseHandle arg1 ;
43581   Dali::BaseHandle *argp1 ;
43582   Dali::Path result;
43583
43584   argp1 = (Dali::BaseHandle *)jarg1;
43585   if (!argp1) {
43586     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43587     return 0;
43588   }
43589   arg1 = *argp1;
43590   {
43591     try {
43592       result = Dali::Path::DownCast(arg1);
43593     } catch (std::out_of_range& e) {
43594       {
43595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43596       };
43597     } catch (std::exception& e) {
43598       {
43599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43600       };
43601     } catch (Dali::DaliException e) {
43602       {
43603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43604       };
43605     } catch (...) {
43606       {
43607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43608       };
43609     }
43610   }
43611
43612   jresult = new Dali::Path((const Dali::Path &)result);
43613   return jresult;
43614 }
43615
43616
43617 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_0() {
43618   void * jresult ;
43619   Dali::Path *result = 0 ;
43620
43621   {
43622     try {
43623       result = (Dali::Path *)new Dali::Path();
43624     } catch (std::out_of_range& e) {
43625       {
43626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43627       };
43628     } catch (std::exception& e) {
43629       {
43630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43631       };
43632     } catch (Dali::DaliException e) {
43633       {
43634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43635       };
43636     } catch (...) {
43637       {
43638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43639       };
43640     }
43641   }
43642
43643   jresult = (void *)result;
43644   return jresult;
43645 }
43646
43647
43648 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path(void * jarg1) {
43649   Dali::Path *arg1 = (Dali::Path *) 0 ;
43650
43651   arg1 = (Dali::Path *)jarg1;
43652   {
43653     try {
43654       delete arg1;
43655     } catch (std::out_of_range& e) {
43656       {
43657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43658       };
43659     } catch (std::exception& e) {
43660       {
43661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43662       };
43663     } catch (Dali::DaliException e) {
43664       {
43665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43666       };
43667     } catch (...) {
43668       {
43669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43670       };
43671     }
43672   }
43673
43674 }
43675
43676
43677 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_1(void * jarg1) {
43678   void * jresult ;
43679   Dali::Path *arg1 = 0 ;
43680   Dali::Path *result = 0 ;
43681
43682   arg1 = (Dali::Path *)jarg1;
43683   if (!arg1) {
43684     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
43685     return 0;
43686   }
43687   {
43688     try {
43689       result = (Dali::Path *)new Dali::Path((Dali::Path const &)*arg1);
43690     } catch (std::out_of_range& e) {
43691       {
43692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43693       };
43694     } catch (std::exception& e) {
43695       {
43696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43697       };
43698     } catch (Dali::DaliException e) {
43699       {
43700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43701       };
43702     } catch (...) {
43703       {
43704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43705       };
43706     }
43707   }
43708
43709   jresult = (void *)result;
43710   return jresult;
43711 }
43712
43713
43714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_Assign(void * jarg1, void * jarg2) {
43715   void * jresult ;
43716   Dali::Path *arg1 = (Dali::Path *) 0 ;
43717   Dali::Path *arg2 = 0 ;
43718   Dali::Path *result = 0 ;
43719
43720   arg1 = (Dali::Path *)jarg1;
43721   arg2 = (Dali::Path *)jarg2;
43722   if (!arg2) {
43723     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
43724     return 0;
43725   }
43726   {
43727     try {
43728       result = (Dali::Path *) &(arg1)->operator =((Dali::Path const &)*arg2);
43729     } catch (std::out_of_range& e) {
43730       {
43731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43732       };
43733     } catch (std::exception& e) {
43734       {
43735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43736       };
43737     } catch (Dali::DaliException e) {
43738       {
43739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43740       };
43741     } catch (...) {
43742       {
43743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43744       };
43745     }
43746   }
43747
43748   jresult = (void *)result;
43749   return jresult;
43750 }
43751
43752
43753 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddPoint(void * jarg1, void * jarg2) {
43754   Dali::Path *arg1 = (Dali::Path *) 0 ;
43755   Dali::Vector3 *arg2 = 0 ;
43756
43757   arg1 = (Dali::Path *)jarg1;
43758   arg2 = (Dali::Vector3 *)jarg2;
43759   if (!arg2) {
43760     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43761     return ;
43762   }
43763   {
43764     try {
43765       (arg1)->AddPoint((Dali::Vector3 const &)*arg2);
43766     } catch (std::out_of_range& e) {
43767       {
43768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43769       };
43770     } catch (std::exception& e) {
43771       {
43772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43773       };
43774     } catch (Dali::DaliException e) {
43775       {
43776         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43777       };
43778     } catch (...) {
43779       {
43780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43781       };
43782     }
43783   }
43784
43785 }
43786
43787
43788 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddControlPoint(void * jarg1, void * jarg2) {
43789   Dali::Path *arg1 = (Dali::Path *) 0 ;
43790   Dali::Vector3 *arg2 = 0 ;
43791
43792   arg1 = (Dali::Path *)jarg1;
43793   arg2 = (Dali::Vector3 *)jarg2;
43794   if (!arg2) {
43795     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43796     return ;
43797   }
43798   {
43799     try {
43800       (arg1)->AddControlPoint((Dali::Vector3 const &)*arg2);
43801     } catch (std::out_of_range& e) {
43802       {
43803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43804       };
43805     } catch (std::exception& e) {
43806       {
43807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43808       };
43809     } catch (Dali::DaliException e) {
43810       {
43811         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43812       };
43813     } catch (...) {
43814       {
43815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43816       };
43817     }
43818   }
43819
43820 }
43821
43822
43823 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_GenerateControlPoints(void * jarg1, float jarg2) {
43824   Dali::Path *arg1 = (Dali::Path *) 0 ;
43825   float arg2 ;
43826
43827   arg1 = (Dali::Path *)jarg1;
43828   arg2 = (float)jarg2;
43829   {
43830     try {
43831       (arg1)->GenerateControlPoints(arg2);
43832     } catch (std::out_of_range& e) {
43833       {
43834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43835       };
43836     } catch (std::exception& e) {
43837       {
43838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43839       };
43840     } catch (Dali::DaliException e) {
43841       {
43842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43843       };
43844     } catch (...) {
43845       {
43846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43847       };
43848     }
43849   }
43850
43851 }
43852
43853
43854 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_Sample(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
43855   Dali::Path *arg1 = (Dali::Path *) 0 ;
43856   float arg2 ;
43857   Dali::Vector3 *arg3 = 0 ;
43858   Dali::Vector3 *arg4 = 0 ;
43859
43860   arg1 = (Dali::Path *)jarg1;
43861   arg2 = (float)jarg2;
43862   arg3 = (Dali::Vector3 *)jarg3;
43863   if (!arg3) {
43864     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
43865     return ;
43866   }
43867   arg4 = (Dali::Vector3 *)jarg4;
43868   if (!arg4) {
43869     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
43870     return ;
43871   }
43872   {
43873     try {
43874       ((Dali::Path const *)arg1)->Sample(arg2,*arg3,*arg4);
43875     } catch (std::out_of_range& e) {
43876       {
43877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43878       };
43879     } catch (std::exception& e) {
43880       {
43881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43882       };
43883     } catch (Dali::DaliException e) {
43884       {
43885         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43886       };
43887     } catch (...) {
43888       {
43889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43890       };
43891     }
43892   }
43893
43894 }
43895
43896
43897 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetPoint(void * jarg1, unsigned long jarg2) {
43898   void * jresult ;
43899   Dali::Path *arg1 = (Dali::Path *) 0 ;
43900   size_t arg2 ;
43901   Dali::Vector3 *result = 0 ;
43902
43903   arg1 = (Dali::Path *)jarg1;
43904   arg2 = (size_t)jarg2;
43905   {
43906     try {
43907       result = (Dali::Vector3 *) &(arg1)->GetPoint(arg2);
43908     } catch (std::out_of_range& e) {
43909       {
43910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43911       };
43912     } catch (std::exception& e) {
43913       {
43914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43915       };
43916     } catch (Dali::DaliException e) {
43917       {
43918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43919       };
43920     } catch (...) {
43921       {
43922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43923       };
43924     }
43925   }
43926
43927   jresult = (void *)result;
43928   return jresult;
43929 }
43930
43931
43932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetControlPoint(void * jarg1, unsigned long jarg2) {
43933   void * jresult ;
43934   Dali::Path *arg1 = (Dali::Path *) 0 ;
43935   size_t arg2 ;
43936   Dali::Vector3 *result = 0 ;
43937
43938   arg1 = (Dali::Path *)jarg1;
43939   arg2 = (size_t)jarg2;
43940   {
43941     try {
43942       result = (Dali::Vector3 *) &(arg1)->GetControlPoint(arg2);
43943     } catch (std::out_of_range& e) {
43944       {
43945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43946       };
43947     } catch (std::exception& e) {
43948       {
43949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43950       };
43951     } catch (Dali::DaliException e) {
43952       {
43953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43954       };
43955     } catch (...) {
43956       {
43957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43958       };
43959     }
43960   }
43961
43962   jresult = (void *)result;
43963   return jresult;
43964 }
43965
43966
43967 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Path_GetPointCount(void * jarg1) {
43968   unsigned long jresult ;
43969   Dali::Path *arg1 = (Dali::Path *) 0 ;
43970   size_t result;
43971
43972   arg1 = (Dali::Path *)jarg1;
43973   {
43974     try {
43975       result = ((Dali::Path const *)arg1)->GetPointCount();
43976     } catch (std::out_of_range& e) {
43977       {
43978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43979       };
43980     } catch (std::exception& e) {
43981       {
43982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43983       };
43984     } catch (Dali::DaliException e) {
43985       {
43986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43987       };
43988     } catch (...) {
43989       {
43990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43991       };
43992     }
43993   }
43994
43995   jresult = (unsigned long)result;
43996   return jresult;
43997 }
43998
43999
44000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_0(float jarg1) {
44001   void * jresult ;
44002   float arg1 ;
44003   Dali::TimePeriod *result = 0 ;
44004
44005   arg1 = (float)jarg1;
44006   {
44007     try {
44008       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1);
44009     } catch (std::out_of_range& e) {
44010       {
44011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44012       };
44013     } catch (std::exception& e) {
44014       {
44015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44016       };
44017     } catch (Dali::DaliException e) {
44018       {
44019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44020       };
44021     } catch (...) {
44022       {
44023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44024       };
44025     }
44026   }
44027
44028   jresult = (void *)result;
44029   return jresult;
44030 }
44031
44032
44033 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_1(float jarg1, float jarg2) {
44034   void * jresult ;
44035   float arg1 ;
44036   float arg2 ;
44037   Dali::TimePeriod *result = 0 ;
44038
44039   arg1 = (float)jarg1;
44040   arg2 = (float)jarg2;
44041   {
44042     try {
44043       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1,arg2);
44044     } catch (std::out_of_range& e) {
44045       {
44046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44047       };
44048     } catch (std::exception& e) {
44049       {
44050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44051       };
44052     } catch (Dali::DaliException e) {
44053       {
44054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44055       };
44056     } catch (...) {
44057       {
44058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44059       };
44060     }
44061   }
44062
44063   jresult = (void *)result;
44064   return jresult;
44065 }
44066
44067
44068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimePeriod(void * jarg1) {
44069   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44070
44071   arg1 = (Dali::TimePeriod *)jarg1;
44072   {
44073     try {
44074       delete arg1;
44075     } catch (std::out_of_range& e) {
44076       {
44077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44078       };
44079     } catch (std::exception& e) {
44080       {
44081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44082       };
44083     } catch (Dali::DaliException e) {
44084       {
44085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44086       };
44087     } catch (...) {
44088       {
44089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44090       };
44091     }
44092   }
44093
44094 }
44095
44096
44097 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_set(void * jarg1, float jarg2) {
44098   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44099   float arg2 ;
44100
44101   arg1 = (Dali::TimePeriod *)jarg1;
44102   arg2 = (float)jarg2;
44103   if (arg1) (arg1)->delaySeconds = arg2;
44104 }
44105
44106
44107 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_get(void * jarg1) {
44108   float jresult ;
44109   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44110   float result;
44111
44112   arg1 = (Dali::TimePeriod *)jarg1;
44113   result = (float) ((arg1)->delaySeconds);
44114   jresult = result;
44115   return jresult;
44116 }
44117
44118
44119 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_set(void * jarg1, float jarg2) {
44120   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44121   float arg2 ;
44122
44123   arg1 = (Dali::TimePeriod *)jarg1;
44124   arg2 = (float)jarg2;
44125   if (arg1) (arg1)->durationSeconds = arg2;
44126 }
44127
44128
44129 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_get(void * jarg1) {
44130   float jresult ;
44131   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44132   float result;
44133
44134   arg1 = (Dali::TimePeriod *)jarg1;
44135   result = (float) ((arg1)->durationSeconds);
44136   jresult = result;
44137   return jresult;
44138 }
44139
44140 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_VALUE_get() {
44141   int jresult ;
44142   int result;
44143
44144   result = (int)Dali::LinearConstrainer::Property::VALUE;
44145   jresult = (int)result;
44146   return jresult;
44147 }
44148
44149
44150 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_PROGRESS_get() {
44151   int jresult ;
44152   int result;
44153
44154   result = (int)Dali::LinearConstrainer::Property::PROGRESS;
44155   jresult = (int)result;
44156   return jresult;
44157 }
44158
44159
44160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer_Property() {
44161   void * jresult ;
44162   Dali::LinearConstrainer::Property *result = 0 ;
44163
44164   {
44165     try {
44166       result = (Dali::LinearConstrainer::Property *)new Dali::LinearConstrainer::Property();
44167     } catch (std::out_of_range& e) {
44168       {
44169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44170       };
44171     } catch (std::exception& e) {
44172       {
44173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44174       };
44175     } catch (Dali::DaliException e) {
44176       {
44177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44178       };
44179     } catch (...) {
44180       {
44181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44182       };
44183     }
44184   }
44185
44186   jresult = (void *)result;
44187   return jresult;
44188 }
44189
44190
44191 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer_Property(void * jarg1) {
44192   Dali::LinearConstrainer::Property *arg1 = (Dali::LinearConstrainer::Property *) 0 ;
44193
44194   arg1 = (Dali::LinearConstrainer::Property *)jarg1;
44195   {
44196     try {
44197       delete arg1;
44198     } catch (std::out_of_range& e) {
44199       {
44200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44201       };
44202     } catch (std::exception& e) {
44203       {
44204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44205       };
44206     } catch (Dali::DaliException e) {
44207       {
44208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44209       };
44210     } catch (...) {
44211       {
44212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44213       };
44214     }
44215   }
44216
44217 }
44218
44219
44220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_New() {
44221   void * jresult ;
44222   Dali::LinearConstrainer result;
44223
44224   {
44225     try {
44226       result = Dali::LinearConstrainer::New();
44227     } catch (std::out_of_range& e) {
44228       {
44229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44230       };
44231     } catch (std::exception& e) {
44232       {
44233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44234       };
44235     } catch (Dali::DaliException e) {
44236       {
44237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44238       };
44239     } catch (...) {
44240       {
44241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44242       };
44243     }
44244   }
44245
44246   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
44247   return jresult;
44248 }
44249
44250
44251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_DownCast(void * jarg1) {
44252   void * jresult ;
44253   Dali::BaseHandle arg1 ;
44254   Dali::BaseHandle *argp1 ;
44255   Dali::LinearConstrainer result;
44256
44257   argp1 = (Dali::BaseHandle *)jarg1;
44258   if (!argp1) {
44259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
44260     return 0;
44261   }
44262   arg1 = *argp1;
44263   {
44264     try {
44265       result = Dali::LinearConstrainer::DownCast(arg1);
44266     } catch (std::out_of_range& e) {
44267       {
44268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44269       };
44270     } catch (std::exception& e) {
44271       {
44272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44273       };
44274     } catch (Dali::DaliException e) {
44275       {
44276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44277       };
44278     } catch (...) {
44279       {
44280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44281       };
44282     }
44283   }
44284
44285   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
44286   return jresult;
44287 }
44288
44289
44290 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_0() {
44291   void * jresult ;
44292   Dali::LinearConstrainer *result = 0 ;
44293
44294   {
44295     try {
44296       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer();
44297     } catch (std::out_of_range& e) {
44298       {
44299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44300       };
44301     } catch (std::exception& e) {
44302       {
44303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44304       };
44305     } catch (Dali::DaliException e) {
44306       {
44307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44308       };
44309     } catch (...) {
44310       {
44311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44312       };
44313     }
44314   }
44315
44316   jresult = (void *)result;
44317   return jresult;
44318 }
44319
44320
44321 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer(void * jarg1) {
44322   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44323
44324   arg1 = (Dali::LinearConstrainer *)jarg1;
44325   {
44326     try {
44327       delete arg1;
44328     } catch (std::out_of_range& e) {
44329       {
44330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44331       };
44332     } catch (std::exception& e) {
44333       {
44334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44335       };
44336     } catch (Dali::DaliException e) {
44337       {
44338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44339       };
44340     } catch (...) {
44341       {
44342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44343       };
44344     }
44345   }
44346
44347 }
44348
44349
44350 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_1(void * jarg1) {
44351   void * jresult ;
44352   Dali::LinearConstrainer *arg1 = 0 ;
44353   Dali::LinearConstrainer *result = 0 ;
44354
44355   arg1 = (Dali::LinearConstrainer *)jarg1;
44356   if (!arg1) {
44357     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
44358     return 0;
44359   }
44360   {
44361     try {
44362       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer((Dali::LinearConstrainer const &)*arg1);
44363     } catch (std::out_of_range& e) {
44364       {
44365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44366       };
44367     } catch (std::exception& e) {
44368       {
44369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44370       };
44371     } catch (Dali::DaliException e) {
44372       {
44373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44374       };
44375     } catch (...) {
44376       {
44377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44378       };
44379     }
44380   }
44381
44382   jresult = (void *)result;
44383   return jresult;
44384 }
44385
44386
44387 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_Assign(void * jarg1, void * jarg2) {
44388   void * jresult ;
44389   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44390   Dali::LinearConstrainer *arg2 = 0 ;
44391   Dali::LinearConstrainer *result = 0 ;
44392
44393   arg1 = (Dali::LinearConstrainer *)jarg1;
44394   arg2 = (Dali::LinearConstrainer *)jarg2;
44395   if (!arg2) {
44396     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
44397     return 0;
44398   }
44399   {
44400     try {
44401       result = (Dali::LinearConstrainer *) &(arg1)->operator =((Dali::LinearConstrainer const &)*arg2);
44402     } catch (std::out_of_range& e) {
44403       {
44404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44405       };
44406     } catch (std::exception& e) {
44407       {
44408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44409       };
44410     } catch (Dali::DaliException e) {
44411       {
44412         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44413       };
44414     } catch (...) {
44415       {
44416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44417       };
44418     }
44419   }
44420
44421   jresult = (void *)result;
44422   return jresult;
44423 }
44424
44425
44426 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
44427   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44428   SwigValueWrapper< Dali::Property > arg2 ;
44429   SwigValueWrapper< Dali::Property > arg3 ;
44430   Dali::Vector2 *arg4 = 0 ;
44431   Dali::Vector2 *arg5 = 0 ;
44432   Dali::Property *argp2 ;
44433   Dali::Property *argp3 ;
44434
44435   arg1 = (Dali::LinearConstrainer *)jarg1;
44436   argp2 = (Dali::Property *)jarg2;
44437   if (!argp2) {
44438     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44439     return ;
44440   }
44441   arg2 = *argp2;
44442   argp3 = (Dali::Property *)jarg3;
44443   if (!argp3) {
44444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44445     return ;
44446   }
44447   arg3 = *argp3;
44448   arg4 = (Dali::Vector2 *)jarg4;
44449   if (!arg4) {
44450     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44451     return ;
44452   }
44453   arg5 = (Dali::Vector2 *)jarg5;
44454   if (!arg5) {
44455     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44456     return ;
44457   }
44458   {
44459     try {
44460       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
44461     } catch (std::out_of_range& e) {
44462       {
44463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44464       };
44465     } catch (std::exception& e) {
44466       {
44467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44468       };
44469     } catch (Dali::DaliException e) {
44470       {
44471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44472       };
44473     } catch (...) {
44474       {
44475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44476       };
44477     }
44478   }
44479
44480 }
44481
44482
44483 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
44484   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44485   SwigValueWrapper< Dali::Property > arg2 ;
44486   SwigValueWrapper< Dali::Property > arg3 ;
44487   Dali::Vector2 *arg4 = 0 ;
44488   Dali::Property *argp2 ;
44489   Dali::Property *argp3 ;
44490
44491   arg1 = (Dali::LinearConstrainer *)jarg1;
44492   argp2 = (Dali::Property *)jarg2;
44493   if (!argp2) {
44494     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44495     return ;
44496   }
44497   arg2 = *argp2;
44498   argp3 = (Dali::Property *)jarg3;
44499   if (!argp3) {
44500     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44501     return ;
44502   }
44503   arg3 = *argp3;
44504   arg4 = (Dali::Vector2 *)jarg4;
44505   if (!arg4) {
44506     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44507     return ;
44508   }
44509   {
44510     try {
44511       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
44512     } catch (std::out_of_range& e) {
44513       {
44514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44515       };
44516     } catch (std::exception& e) {
44517       {
44518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44519       };
44520     } catch (Dali::DaliException e) {
44521       {
44522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44523       };
44524     } catch (...) {
44525       {
44526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44527       };
44528     }
44529   }
44530
44531 }
44532
44533
44534 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Remove(void * jarg1, void * jarg2) {
44535   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44536   Dali::Handle *arg2 = 0 ;
44537
44538   arg1 = (Dali::LinearConstrainer *)jarg1;
44539   arg2 = (Dali::Handle *)jarg2;
44540   if (!arg2) {
44541     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
44542     return ;
44543   }
44544   {
44545     try {
44546       (arg1)->Remove(*arg2);
44547     } catch (std::out_of_range& e) {
44548       {
44549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44550       };
44551     } catch (std::exception& e) {
44552       {
44553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44554       };
44555     } catch (Dali::DaliException e) {
44556       {
44557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44558       };
44559     } catch (...) {
44560       {
44561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44562       };
44563     }
44564   }
44565
44566 }
44567
44568
44569 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_FORWARD_get() {
44570   int jresult ;
44571   int result;
44572
44573   result = (int)Dali::PathConstrainer::Property::FORWARD;
44574   jresult = (int)result;
44575   return jresult;
44576 }
44577
44578
44579 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_POINTS_get() {
44580   int jresult ;
44581   int result;
44582
44583   result = (int)Dali::PathConstrainer::Property::POINTS;
44584   jresult = (int)result;
44585   return jresult;
44586 }
44587
44588
44589 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_CONTROL_POINTS_get() {
44590   int jresult ;
44591   int result;
44592
44593   result = (int)Dali::PathConstrainer::Property::CONTROL_POINTS;
44594   jresult = (int)result;
44595   return jresult;
44596 }
44597
44598
44599 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer_Property() {
44600   void * jresult ;
44601   Dali::PathConstrainer::Property *result = 0 ;
44602
44603   {
44604     try {
44605       result = (Dali::PathConstrainer::Property *)new Dali::PathConstrainer::Property();
44606     } catch (std::out_of_range& e) {
44607       {
44608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44609       };
44610     } catch (std::exception& e) {
44611       {
44612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44613       };
44614     } catch (Dali::DaliException e) {
44615       {
44616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44617       };
44618     } catch (...) {
44619       {
44620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44621       };
44622     }
44623   }
44624
44625   jresult = (void *)result;
44626   return jresult;
44627 }
44628
44629
44630 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer_Property(void * jarg1) {
44631   Dali::PathConstrainer::Property *arg1 = (Dali::PathConstrainer::Property *) 0 ;
44632
44633   arg1 = (Dali::PathConstrainer::Property *)jarg1;
44634   {
44635     try {
44636       delete arg1;
44637     } catch (std::out_of_range& e) {
44638       {
44639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44640       };
44641     } catch (std::exception& e) {
44642       {
44643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44644       };
44645     } catch (Dali::DaliException e) {
44646       {
44647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44648       };
44649     } catch (...) {
44650       {
44651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44652       };
44653     }
44654   }
44655
44656 }
44657
44658
44659 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_New() {
44660   void * jresult ;
44661   Dali::PathConstrainer result;
44662
44663   {
44664     try {
44665       result = Dali::PathConstrainer::New();
44666     } catch (std::out_of_range& e) {
44667       {
44668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44669       };
44670     } catch (std::exception& e) {
44671       {
44672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44673       };
44674     } catch (Dali::DaliException e) {
44675       {
44676         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44677       };
44678     } catch (...) {
44679       {
44680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44681       };
44682     }
44683   }
44684
44685   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
44686   return jresult;
44687 }
44688
44689
44690 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_DownCast(void * jarg1) {
44691   void * jresult ;
44692   Dali::BaseHandle arg1 ;
44693   Dali::BaseHandle *argp1 ;
44694   Dali::PathConstrainer result;
44695
44696   argp1 = (Dali::BaseHandle *)jarg1;
44697   if (!argp1) {
44698     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
44699     return 0;
44700   }
44701   arg1 = *argp1;
44702   {
44703     try {
44704       result = Dali::PathConstrainer::DownCast(arg1);
44705     } catch (std::out_of_range& e) {
44706       {
44707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44708       };
44709     } catch (std::exception& e) {
44710       {
44711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44712       };
44713     } catch (Dali::DaliException e) {
44714       {
44715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44716       };
44717     } catch (...) {
44718       {
44719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44720       };
44721     }
44722   }
44723
44724   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
44725   return jresult;
44726 }
44727
44728
44729 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_0() {
44730   void * jresult ;
44731   Dali::PathConstrainer *result = 0 ;
44732
44733   {
44734     try {
44735       result = (Dali::PathConstrainer *)new Dali::PathConstrainer();
44736     } catch (std::out_of_range& e) {
44737       {
44738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44739       };
44740     } catch (std::exception& e) {
44741       {
44742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44743       };
44744     } catch (Dali::DaliException e) {
44745       {
44746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44747       };
44748     } catch (...) {
44749       {
44750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44751       };
44752     }
44753   }
44754
44755   jresult = (void *)result;
44756   return jresult;
44757 }
44758
44759
44760 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer(void * jarg1) {
44761   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44762
44763   arg1 = (Dali::PathConstrainer *)jarg1;
44764   {
44765     try {
44766       delete arg1;
44767     } catch (std::out_of_range& e) {
44768       {
44769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44770       };
44771     } catch (std::exception& e) {
44772       {
44773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44774       };
44775     } catch (Dali::DaliException e) {
44776       {
44777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44778       };
44779     } catch (...) {
44780       {
44781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44782       };
44783     }
44784   }
44785
44786 }
44787
44788
44789 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_1(void * jarg1) {
44790   void * jresult ;
44791   Dali::PathConstrainer *arg1 = 0 ;
44792   Dali::PathConstrainer *result = 0 ;
44793
44794   arg1 = (Dali::PathConstrainer *)jarg1;
44795   if (!arg1) {
44796     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
44797     return 0;
44798   }
44799   {
44800     try {
44801       result = (Dali::PathConstrainer *)new Dali::PathConstrainer((Dali::PathConstrainer const &)*arg1);
44802     } catch (std::out_of_range& e) {
44803       {
44804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44805       };
44806     } catch (std::exception& e) {
44807       {
44808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44809       };
44810     } catch (Dali::DaliException e) {
44811       {
44812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44813       };
44814     } catch (...) {
44815       {
44816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44817       };
44818     }
44819   }
44820
44821   jresult = (void *)result;
44822   return jresult;
44823 }
44824
44825
44826 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_Assign(void * jarg1, void * jarg2) {
44827   void * jresult ;
44828   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44829   Dali::PathConstrainer *arg2 = 0 ;
44830   Dali::PathConstrainer *result = 0 ;
44831
44832   arg1 = (Dali::PathConstrainer *)jarg1;
44833   arg2 = (Dali::PathConstrainer *)jarg2;
44834   if (!arg2) {
44835     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
44836     return 0;
44837   }
44838   {
44839     try {
44840       result = (Dali::PathConstrainer *) &(arg1)->operator =((Dali::PathConstrainer const &)*arg2);
44841     } catch (std::out_of_range& e) {
44842       {
44843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44844       };
44845     } catch (std::exception& e) {
44846       {
44847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44848       };
44849     } catch (Dali::DaliException e) {
44850       {
44851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44852       };
44853     } catch (...) {
44854       {
44855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44856       };
44857     }
44858   }
44859
44860   jresult = (void *)result;
44861   return jresult;
44862 }
44863
44864
44865 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
44866   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44867   SwigValueWrapper< Dali::Property > arg2 ;
44868   SwigValueWrapper< Dali::Property > arg3 ;
44869   Dali::Vector2 *arg4 = 0 ;
44870   Dali::Vector2 *arg5 = 0 ;
44871   Dali::Property *argp2 ;
44872   Dali::Property *argp3 ;
44873
44874   arg1 = (Dali::PathConstrainer *)jarg1;
44875   argp2 = (Dali::Property *)jarg2;
44876   if (!argp2) {
44877     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44878     return ;
44879   }
44880   arg2 = *argp2;
44881   argp3 = (Dali::Property *)jarg3;
44882   if (!argp3) {
44883     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44884     return ;
44885   }
44886   arg3 = *argp3;
44887   arg4 = (Dali::Vector2 *)jarg4;
44888   if (!arg4) {
44889     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44890     return ;
44891   }
44892   arg5 = (Dali::Vector2 *)jarg5;
44893   if (!arg5) {
44894     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44895     return ;
44896   }
44897   {
44898     try {
44899       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
44900     } catch (std::out_of_range& e) {
44901       {
44902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44903       };
44904     } catch (std::exception& e) {
44905       {
44906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44907       };
44908     } catch (Dali::DaliException e) {
44909       {
44910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44911       };
44912     } catch (...) {
44913       {
44914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44915       };
44916     }
44917   }
44918
44919 }
44920
44921
44922 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
44923   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44924   SwigValueWrapper< Dali::Property > arg2 ;
44925   SwigValueWrapper< Dali::Property > arg3 ;
44926   Dali::Vector2 *arg4 = 0 ;
44927   Dali::Property *argp2 ;
44928   Dali::Property *argp3 ;
44929
44930   arg1 = (Dali::PathConstrainer *)jarg1;
44931   argp2 = (Dali::Property *)jarg2;
44932   if (!argp2) {
44933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44934     return ;
44935   }
44936   arg2 = *argp2;
44937   argp3 = (Dali::Property *)jarg3;
44938   if (!argp3) {
44939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44940     return ;
44941   }
44942   arg3 = *argp3;
44943   arg4 = (Dali::Vector2 *)jarg4;
44944   if (!arg4) {
44945     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44946     return ;
44947   }
44948   {
44949     try {
44950       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
44951     } catch (std::out_of_range& e) {
44952       {
44953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44954       };
44955     } catch (std::exception& e) {
44956       {
44957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44958       };
44959     } catch (Dali::DaliException e) {
44960       {
44961         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44962       };
44963     } catch (...) {
44964       {
44965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44966       };
44967     }
44968   }
44969
44970 }
44971
44972
44973 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Remove(void * jarg1, void * jarg2) {
44974   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44975   Dali::Handle *arg2 = 0 ;
44976
44977   arg1 = (Dali::PathConstrainer *)jarg1;
44978   arg2 = (Dali::Handle *)jarg2;
44979   if (!arg2) {
44980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
44981     return ;
44982   }
44983   {
44984     try {
44985       (arg1)->Remove(*arg2);
44986     } catch (std::out_of_range& e) {
44987       {
44988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44989       };
44990     } catch (std::exception& e) {
44991       {
44992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44993       };
44994     } catch (Dali::DaliException e) {
44995       {
44996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44997       };
44998     } catch (...) {
44999       {
45000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45001       };
45002     }
45003   }
45004
45005 }
45006
45007
45008 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FittingModeDefault_get() {
45009   int jresult ;
45010   Dali::FittingMode::Type result;
45011
45012   result = (Dali::FittingMode::Type)(Dali::FittingMode::Type)Dali::FittingMode::DEFAULT;
45013   jresult = (int)result;
45014   return jresult;
45015 }
45016
45017
45018 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_DEFAULT_get() {
45019   int jresult ;
45020   Dali::SamplingMode::Type result;
45021
45022   result = (Dali::SamplingMode::Type)(Dali::SamplingMode::Type)Dali::SamplingMode::DEFAULT;
45023   jresult = (int)result;
45024   return jresult;
45025 }
45026
45027
45028 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_0() {
45029   void * jresult ;
45030   Dali::BufferImage *result = 0 ;
45031
45032   {
45033     try {
45034       result = (Dali::BufferImage *)new Dali::BufferImage();
45035     } catch (std::out_of_range& e) {
45036       {
45037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45038       };
45039     } catch (std::exception& e) {
45040       {
45041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45042       };
45043     } catch (Dali::DaliException e) {
45044       {
45045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45046       };
45047     } catch (...) {
45048       {
45049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45050       };
45051     }
45052   }
45053
45054   jresult = (void *)result;
45055   return jresult;
45056 }
45057
45058
45059 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3) {
45060   void * jresult ;
45061   unsigned int arg1 ;
45062   unsigned int arg2 ;
45063   Dali::Pixel::Format arg3 ;
45064   Dali::BufferImage result;
45065
45066   arg1 = (unsigned int)jarg1;
45067   arg2 = (unsigned int)jarg2;
45068   arg3 = (Dali::Pixel::Format)jarg3;
45069   {
45070     try {
45071       result = Dali::BufferImage::New(arg1,arg2,arg3);
45072     } catch (std::out_of_range& e) {
45073       {
45074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45075       };
45076     } catch (std::exception& e) {
45077       {
45078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45079       };
45080     } catch (Dali::DaliException e) {
45081       {
45082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45083       };
45084     } catch (...) {
45085       {
45086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45087       };
45088     }
45089   }
45090
45091   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45092   return jresult;
45093 }
45094
45095
45096 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
45097   void * jresult ;
45098   unsigned int arg1 ;
45099   unsigned int arg2 ;
45100   Dali::BufferImage result;
45101
45102   arg1 = (unsigned int)jarg1;
45103   arg2 = (unsigned int)jarg2;
45104   {
45105     try {
45106       result = Dali::BufferImage::New(arg1,arg2);
45107     } catch (std::out_of_range& e) {
45108       {
45109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45110       };
45111     } catch (std::exception& e) {
45112       {
45113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45114       };
45115     } catch (Dali::DaliException e) {
45116       {
45117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45118       };
45119     } catch (...) {
45120       {
45121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45122       };
45123     }
45124   }
45125
45126   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45127   return jresult;
45128 }
45129
45130
45131 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_2(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4, unsigned int jarg5) {
45132   void * jresult ;
45133   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
45134   unsigned int arg2 ;
45135   unsigned int arg3 ;
45136   Dali::Pixel::Format arg4 ;
45137   unsigned int arg5 ;
45138   Dali::BufferImage result;
45139
45140   arg1 = jarg1;
45141   arg2 = (unsigned int)jarg2;
45142   arg3 = (unsigned int)jarg3;
45143   arg4 = (Dali::Pixel::Format)jarg4;
45144   arg5 = (unsigned int)jarg5;
45145   {
45146     try {
45147       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4,arg5);
45148     } catch (std::out_of_range& e) {
45149       {
45150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45151       };
45152     } catch (std::exception& e) {
45153       {
45154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45155       };
45156     } catch (Dali::DaliException e) {
45157       {
45158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45159       };
45160     } catch (...) {
45161       {
45162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45163       };
45164     }
45165   }
45166
45167   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45168
45169
45170   return jresult;
45171 }
45172
45173
45174 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_3(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4) {
45175   void * jresult ;
45176   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
45177   unsigned int arg2 ;
45178   unsigned int arg3 ;
45179   Dali::Pixel::Format arg4 ;
45180   Dali::BufferImage result;
45181
45182   arg1 = jarg1;
45183   arg2 = (unsigned int)jarg2;
45184   arg3 = (unsigned int)jarg3;
45185   arg4 = (Dali::Pixel::Format)jarg4;
45186   {
45187     try {
45188       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4);
45189     } catch (std::out_of_range& e) {
45190       {
45191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45192       };
45193     } catch (std::exception& e) {
45194       {
45195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45196       };
45197     } catch (Dali::DaliException e) {
45198       {
45199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45200       };
45201     } catch (...) {
45202       {
45203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45204       };
45205     }
45206   }
45207
45208   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45209
45210
45211   return jresult;
45212 }
45213
45214
45215 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_4(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3) {
45216   void * jresult ;
45217   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
45218   unsigned int arg2 ;
45219   unsigned int arg3 ;
45220   Dali::BufferImage result;
45221
45222   arg1 = jarg1;
45223   arg2 = (unsigned int)jarg2;
45224   arg3 = (unsigned int)jarg3;
45225   {
45226     try {
45227       result = Dali::BufferImage::New(arg1,arg2,arg3);
45228     } catch (std::out_of_range& e) {
45229       {
45230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45231       };
45232     } catch (std::exception& e) {
45233       {
45234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45235       };
45236     } catch (Dali::DaliException e) {
45237       {
45238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45239       };
45240     } catch (...) {
45241       {
45242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45243       };
45244     }
45245   }
45246
45247   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45248
45249
45250   return jresult;
45251 }
45252
45253
45254 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_DownCast(void * jarg1) {
45255   void * jresult ;
45256   Dali::BaseHandle arg1 ;
45257   Dali::BaseHandle *argp1 ;
45258   Dali::BufferImage result;
45259
45260   argp1 = (Dali::BaseHandle *)jarg1;
45261   if (!argp1) {
45262     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
45263     return 0;
45264   }
45265   arg1 = *argp1;
45266   {
45267     try {
45268       result = Dali::BufferImage::DownCast(arg1);
45269     } catch (std::out_of_range& e) {
45270       {
45271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45272       };
45273     } catch (std::exception& e) {
45274       {
45275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45276       };
45277     } catch (Dali::DaliException e) {
45278       {
45279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45280       };
45281     } catch (...) {
45282       {
45283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45284       };
45285     }
45286   }
45287
45288   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45289   return jresult;
45290 }
45291
45292
45293 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BufferImage(void * jarg1) {
45294   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45295
45296   arg1 = (Dali::BufferImage *)jarg1;
45297   {
45298     try {
45299       delete arg1;
45300     } catch (std::out_of_range& e) {
45301       {
45302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45303       };
45304     } catch (std::exception& e) {
45305       {
45306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45307       };
45308     } catch (Dali::DaliException e) {
45309       {
45310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45311       };
45312     } catch (...) {
45313       {
45314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45315       };
45316     }
45317   }
45318
45319 }
45320
45321
45322 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_1(void * jarg1) {
45323   void * jresult ;
45324   Dali::BufferImage *arg1 = 0 ;
45325   Dali::BufferImage *result = 0 ;
45326
45327   arg1 = (Dali::BufferImage *)jarg1;
45328   if (!arg1) {
45329     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
45330     return 0;
45331   }
45332   {
45333     try {
45334       result = (Dali::BufferImage *)new Dali::BufferImage((Dali::BufferImage const &)*arg1);
45335     } catch (std::out_of_range& e) {
45336       {
45337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45338       };
45339     } catch (std::exception& e) {
45340       {
45341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45342       };
45343     } catch (Dali::DaliException e) {
45344       {
45345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45346       };
45347     } catch (...) {
45348       {
45349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45350       };
45351     }
45352   }
45353
45354   jresult = (void *)result;
45355   return jresult;
45356 }
45357
45358
45359 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_Assign(void * jarg1, void * jarg2) {
45360   void * jresult ;
45361   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45362   Dali::BufferImage *arg2 = 0 ;
45363   Dali::BufferImage *result = 0 ;
45364
45365   arg1 = (Dali::BufferImage *)jarg1;
45366   arg2 = (Dali::BufferImage *)jarg2;
45367   if (!arg2) {
45368     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
45369     return 0;
45370   }
45371   {
45372     try {
45373       result = (Dali::BufferImage *) &(arg1)->operator =((Dali::BufferImage const &)*arg2);
45374     } catch (std::out_of_range& e) {
45375       {
45376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45377       };
45378     } catch (std::exception& e) {
45379       {
45380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45381       };
45382     } catch (Dali::DaliException e) {
45383       {
45384         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45385       };
45386     } catch (...) {
45387       {
45388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45389       };
45390     }
45391   }
45392
45393   jresult = (void *)result;
45394   return jresult;
45395 }
45396
45397
45398 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_WHITE() {
45399   void * jresult ;
45400   Dali::BufferImage result;
45401
45402   {
45403     try {
45404       result = Dali::BufferImage::WHITE();
45405     } catch (std::out_of_range& e) {
45406       {
45407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45408       };
45409     } catch (std::exception& e) {
45410       {
45411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45412       };
45413     } catch (Dali::DaliException e) {
45414       {
45415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45416       };
45417     } catch (...) {
45418       {
45419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45420       };
45421     }
45422   }
45423
45424   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45425   return jresult;
45426 }
45427
45428
45429 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_GetBuffer(void * jarg1) {
45430   void * jresult ;
45431   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45432   Dali::PixelBuffer *result = 0 ;
45433
45434   arg1 = (Dali::BufferImage *)jarg1;
45435   {
45436     try {
45437       result = (Dali::PixelBuffer *)(arg1)->GetBuffer();
45438     } catch (std::out_of_range& e) {
45439       {
45440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45441       };
45442     } catch (std::exception& e) {
45443       {
45444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45445       };
45446     } catch (Dali::DaliException e) {
45447       {
45448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45449       };
45450     } catch (...) {
45451       {
45452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45453       };
45454     }
45455   }
45456
45457   jresult = (void *)result;
45458   return jresult;
45459 }
45460
45461
45462 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferSize(void * jarg1) {
45463   unsigned int jresult ;
45464   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45465   unsigned int result;
45466
45467   arg1 = (Dali::BufferImage *)jarg1;
45468   {
45469     try {
45470       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferSize();
45471     } catch (std::out_of_range& e) {
45472       {
45473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45474       };
45475     } catch (std::exception& e) {
45476       {
45477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45478       };
45479     } catch (Dali::DaliException e) {
45480       {
45481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45482       };
45483     } catch (...) {
45484       {
45485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45486       };
45487     }
45488   }
45489
45490   jresult = result;
45491   return jresult;
45492 }
45493
45494
45495 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferStride(void * jarg1) {
45496   unsigned int jresult ;
45497   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45498   unsigned int result;
45499
45500   arg1 = (Dali::BufferImage *)jarg1;
45501   {
45502     try {
45503       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferStride();
45504     } catch (std::out_of_range& e) {
45505       {
45506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45507       };
45508     } catch (std::exception& e) {
45509       {
45510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45511       };
45512     } catch (Dali::DaliException e) {
45513       {
45514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45515       };
45516     } catch (...) {
45517       {
45518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45519       };
45520     }
45521   }
45522
45523   jresult = result;
45524   return jresult;
45525 }
45526
45527
45528 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BufferImage_GetPixelFormat(void * jarg1) {
45529   int jresult ;
45530   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45531   Dali::Pixel::Format result;
45532
45533   arg1 = (Dali::BufferImage *)jarg1;
45534   {
45535     try {
45536       result = (Dali::Pixel::Format)((Dali::BufferImage const *)arg1)->GetPixelFormat();
45537     } catch (std::out_of_range& e) {
45538       {
45539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45540       };
45541     } catch (std::exception& e) {
45542       {
45543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45544       };
45545     } catch (Dali::DaliException e) {
45546       {
45547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45548       };
45549     } catch (...) {
45550       {
45551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45552       };
45553     }
45554   }
45555
45556   jresult = (int)result;
45557   return jresult;
45558 }
45559
45560
45561 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BufferImage_Update__SWIG_0(void * jarg1) {
45562   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45563
45564   arg1 = (Dali::BufferImage *)jarg1;
45565   {
45566     try {
45567       (arg1)->Update();
45568     } catch (std::out_of_range& e) {
45569       {
45570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45571       };
45572     } catch (std::exception& e) {
45573       {
45574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45575       };
45576     } catch (Dali::DaliException e) {
45577       {
45578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45579       };
45580     } catch (...) {
45581       {
45582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45583       };
45584     }
45585   }
45586
45587 }
45588
45589
45590 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BufferImage_Update__SWIG_1(void * jarg1, void * jarg2) {
45591   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45592   SwigValueWrapper< Dali::Rect< unsigned int > > arg2 ;
45593   Dali::RectArea *argp2 ;
45594
45595   arg1 = (Dali::BufferImage *)jarg1;
45596   argp2 = (Dali::RectArea *)jarg2;
45597   if (!argp2) {
45598     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RectArea", 0);
45599     return ;
45600   }
45601   arg2 = *argp2;
45602   {
45603     try {
45604       (arg1)->Update(arg2);
45605     } catch (std::out_of_range& e) {
45606       {
45607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45608       };
45609     } catch (std::exception& e) {
45610       {
45611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45612       };
45613     } catch (Dali::DaliException e) {
45614       {
45615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45616       };
45617     } catch (...) {
45618       {
45619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45620       };
45621     }
45622   }
45623
45624 }
45625
45626
45627 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_IsDataExternal(void * jarg1) {
45628   unsigned int jresult ;
45629   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45630   bool result;
45631
45632   arg1 = (Dali::BufferImage *)jarg1;
45633   {
45634     try {
45635       result = (bool)((Dali::BufferImage const *)arg1)->IsDataExternal();
45636     } catch (std::out_of_range& e) {
45637       {
45638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45639       };
45640     } catch (std::exception& e) {
45641       {
45642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45643       };
45644     } catch (Dali::DaliException e) {
45645       {
45646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45647       };
45648     } catch (...) {
45649       {
45650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45651       };
45652     }
45653   }
45654
45655   jresult = result;
45656   return jresult;
45657 }
45658
45659
45660 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EncodedBufferImage__SWIG_0() {
45661   void * jresult ;
45662   Dali::EncodedBufferImage *result = 0 ;
45663
45664   {
45665     try {
45666       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage();
45667     } catch (std::out_of_range& e) {
45668       {
45669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45670       };
45671     } catch (std::exception& e) {
45672       {
45673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45674       };
45675     } catch (Dali::DaliException e) {
45676       {
45677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45678       };
45679     } catch (...) {
45680       {
45681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45682       };
45683     }
45684   }
45685
45686   jresult = (void *)result;
45687   return jresult;
45688 }
45689
45690
45691 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_0(void * jarg1, unsigned long jarg2) {
45692   void * jresult ;
45693   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
45694   std::size_t arg2 ;
45695   Dali::EncodedBufferImage result;
45696
45697   arg1 = (uint8_t *)jarg1;
45698   arg2 = (std::size_t)jarg2;
45699   {
45700     try {
45701       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2);
45702     } catch (std::out_of_range& e) {
45703       {
45704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45705       };
45706     } catch (std::exception& e) {
45707       {
45708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45709       };
45710     } catch (Dali::DaliException e) {
45711       {
45712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45713       };
45714     } catch (...) {
45715       {
45716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45717       };
45718     }
45719   }
45720
45721   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45722   return jresult;
45723 }
45724
45725
45726 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
45727   void * jresult ;
45728   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
45729   std::size_t arg2 ;
45730   Dali::ImageDimensions arg3 ;
45731   Dali::FittingMode::Type arg4 ;
45732   Dali::SamplingMode::Type arg5 ;
45733   bool arg6 ;
45734   Dali::ImageDimensions *argp3 ;
45735   Dali::EncodedBufferImage result;
45736
45737   arg1 = (uint8_t *)jarg1;
45738   arg2 = (std::size_t)jarg2;
45739   argp3 = (Dali::ImageDimensions *)jarg3;
45740   if (!argp3) {
45741     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
45742     return 0;
45743   }
45744   arg3 = *argp3;
45745   arg4 = (Dali::FittingMode::Type)jarg4;
45746   arg5 = (Dali::SamplingMode::Type)jarg5;
45747   arg6 = jarg6 ? true : false;
45748   {
45749     try {
45750       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5,arg6);
45751     } catch (std::out_of_range& e) {
45752       {
45753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45754       };
45755     } catch (std::exception& e) {
45756       {
45757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45758       };
45759     } catch (Dali::DaliException e) {
45760       {
45761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45762       };
45763     } catch (...) {
45764       {
45765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45766       };
45767     }
45768   }
45769
45770   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45771   return jresult;
45772 }
45773
45774
45775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_2(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5) {
45776   void * jresult ;
45777   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
45778   std::size_t arg2 ;
45779   Dali::ImageDimensions arg3 ;
45780   Dali::FittingMode::Type arg4 ;
45781   Dali::SamplingMode::Type arg5 ;
45782   Dali::ImageDimensions *argp3 ;
45783   Dali::EncodedBufferImage result;
45784
45785   arg1 = (uint8_t *)jarg1;
45786   arg2 = (std::size_t)jarg2;
45787   argp3 = (Dali::ImageDimensions *)jarg3;
45788   if (!argp3) {
45789     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
45790     return 0;
45791   }
45792   arg3 = *argp3;
45793   arg4 = (Dali::FittingMode::Type)jarg4;
45794   arg5 = (Dali::SamplingMode::Type)jarg5;
45795   {
45796     try {
45797       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5);
45798     } catch (std::out_of_range& e) {
45799       {
45800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45801       };
45802     } catch (std::exception& e) {
45803       {
45804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45805       };
45806     } catch (Dali::DaliException e) {
45807       {
45808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45809       };
45810     } catch (...) {
45811       {
45812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45813       };
45814     }
45815   }
45816
45817   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45818   return jresult;
45819 }
45820
45821
45822 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_DownCast(void * jarg1) {
45823   void * jresult ;
45824   Dali::BaseHandle arg1 ;
45825   Dali::BaseHandle *argp1 ;
45826   Dali::EncodedBufferImage result;
45827
45828   argp1 = (Dali::BaseHandle *)jarg1;
45829   if (!argp1) {
45830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
45831     return 0;
45832   }
45833   arg1 = *argp1;
45834   {
45835     try {
45836       result = Dali::EncodedBufferImage::DownCast(arg1);
45837     } catch (std::out_of_range& e) {
45838       {
45839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45840       };
45841     } catch (std::exception& e) {
45842       {
45843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45844       };
45845     } catch (Dali::DaliException e) {
45846       {
45847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45848       };
45849     } catch (...) {
45850       {
45851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45852       };
45853     }
45854   }
45855
45856   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45857   return jresult;
45858 }
45859
45860
45861 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_EncodedBufferImage(void * jarg1) {
45862   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
45863
45864   arg1 = (Dali::EncodedBufferImage *)jarg1;
45865   {
45866     try {
45867       delete arg1;
45868     } catch (std::out_of_range& e) {
45869       {
45870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45871       };
45872     } catch (std::exception& e) {
45873       {
45874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45875       };
45876     } catch (Dali::DaliException e) {
45877       {
45878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45879       };
45880     } catch (...) {
45881       {
45882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45883       };
45884     }
45885   }
45886
45887 }
45888
45889
45890 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EncodedBufferImage__SWIG_1(void * jarg1) {
45891   void * jresult ;
45892   Dali::EncodedBufferImage *arg1 = 0 ;
45893   Dali::EncodedBufferImage *result = 0 ;
45894
45895   arg1 = (Dali::EncodedBufferImage *)jarg1;
45896   if (!arg1) {
45897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
45898     return 0;
45899   }
45900   {
45901     try {
45902       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage((Dali::EncodedBufferImage const &)*arg1);
45903     } catch (std::out_of_range& e) {
45904       {
45905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45906       };
45907     } catch (std::exception& e) {
45908       {
45909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45910       };
45911     } catch (Dali::DaliException e) {
45912       {
45913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45914       };
45915     } catch (...) {
45916       {
45917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45918       };
45919     }
45920   }
45921
45922   jresult = (void *)result;
45923   return jresult;
45924 }
45925
45926
45927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_Assign(void * jarg1, void * jarg2) {
45928   void * jresult ;
45929   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
45930   Dali::EncodedBufferImage *arg2 = 0 ;
45931   Dali::EncodedBufferImage *result = 0 ;
45932
45933   arg1 = (Dali::EncodedBufferImage *)jarg1;
45934   arg2 = (Dali::EncodedBufferImage *)jarg2;
45935   if (!arg2) {
45936     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
45937     return 0;
45938   }
45939   {
45940     try {
45941       result = (Dali::EncodedBufferImage *) &(arg1)->operator =((Dali::EncodedBufferImage const &)*arg2);
45942     } catch (std::out_of_range& e) {
45943       {
45944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45945       };
45946     } catch (std::exception& e) {
45947       {
45948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45949       };
45950     } catch (Dali::DaliException e) {
45951       {
45952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45953       };
45954     } catch (...) {
45955       {
45956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45957       };
45958     }
45959   }
45960
45961   jresult = (void *)result;
45962   return jresult;
45963 }
45964
45965
45966 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_0() {
45967   void * jresult ;
45968   Dali::NativeImage *result = 0 ;
45969
45970   {
45971     try {
45972       result = (Dali::NativeImage *)new Dali::NativeImage();
45973     } catch (std::out_of_range& e) {
45974       {
45975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45976       };
45977     } catch (std::exception& e) {
45978       {
45979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45980       };
45981     } catch (Dali::DaliException e) {
45982       {
45983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45984       };
45985     } catch (...) {
45986       {
45987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45988       };
45989     }
45990   }
45991
45992   jresult = (void *)result;
45993   return jresult;
45994 }
45995
45996
45997 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NativeImage(void * jarg1) {
45998   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
45999
46000   arg1 = (Dali::NativeImage *)jarg1;
46001   {
46002     try {
46003       delete arg1;
46004     } catch (std::out_of_range& e) {
46005       {
46006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46007       };
46008     } catch (std::exception& e) {
46009       {
46010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46011       };
46012     } catch (Dali::DaliException e) {
46013       {
46014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46015       };
46016     } catch (...) {
46017       {
46018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46019       };
46020     }
46021   }
46022
46023 }
46024
46025
46026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_1(void * jarg1) {
46027   void * jresult ;
46028   Dali::NativeImage *arg1 = 0 ;
46029   Dali::NativeImage *result = 0 ;
46030
46031   arg1 = (Dali::NativeImage *)jarg1;
46032   if (!arg1) {
46033     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
46034     return 0;
46035   }
46036   {
46037     try {
46038       result = (Dali::NativeImage *)new Dali::NativeImage((Dali::NativeImage const &)*arg1);
46039     } catch (std::out_of_range& e) {
46040       {
46041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46042       };
46043     } catch (std::exception& e) {
46044       {
46045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46046       };
46047     } catch (Dali::DaliException e) {
46048       {
46049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46050       };
46051     } catch (...) {
46052       {
46053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46054       };
46055     }
46056   }
46057
46058   jresult = (void *)result;
46059   return jresult;
46060 }
46061
46062
46063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_Assign(void * jarg1, void * jarg2) {
46064   void * jresult ;
46065   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46066   Dali::NativeImage *arg2 = 0 ;
46067   Dali::NativeImage *result = 0 ;
46068
46069   arg1 = (Dali::NativeImage *)jarg1;
46070   arg2 = (Dali::NativeImage *)jarg2;
46071   if (!arg2) {
46072     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
46073     return 0;
46074   }
46075   {
46076     try {
46077       result = (Dali::NativeImage *) &(arg1)->operator =((Dali::NativeImage const &)*arg2);
46078     } catch (std::out_of_range& e) {
46079       {
46080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46081       };
46082     } catch (std::exception& e) {
46083       {
46084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46085       };
46086     } catch (Dali::DaliException e) {
46087       {
46088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46089       };
46090     } catch (...) {
46091       {
46092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46093       };
46094     }
46095   }
46096
46097   jresult = (void *)result;
46098   return jresult;
46099 }
46100
46101
46102 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImage_CreateGlTexture(void * jarg1) {
46103   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46104
46105   arg1 = (Dali::NativeImage *)jarg1;
46106   {
46107     try {
46108       (arg1)->CreateGlTexture();
46109     } catch (std::out_of_range& e) {
46110       {
46111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46112       };
46113     } catch (std::exception& e) {
46114       {
46115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46116       };
46117     } catch (Dali::DaliException e) {
46118       {
46119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46120       };
46121     } catch (...) {
46122       {
46123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46124       };
46125     }
46126   }
46127
46128 }
46129
46130
46131 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_New(void * jarg1) {
46132   void * jresult ;
46133   NativeImageInterface *arg1 = 0 ;
46134   Dali::NativeImage result;
46135
46136   arg1 = (NativeImageInterface *)jarg1;
46137   if (!arg1) {
46138     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
46139     return 0;
46140   }
46141   {
46142     try {
46143       result = Dali::NativeImage::New(*arg1);
46144     } catch (std::out_of_range& e) {
46145       {
46146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46147       };
46148     } catch (std::exception& e) {
46149       {
46150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46151       };
46152     } catch (Dali::DaliException e) {
46153       {
46154         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46155       };
46156     } catch (...) {
46157       {
46158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46159       };
46160     }
46161   }
46162
46163   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
46164   return jresult;
46165 }
46166
46167
46168 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_DownCast(void * jarg1) {
46169   void * jresult ;
46170   Dali::BaseHandle arg1 ;
46171   Dali::BaseHandle *argp1 ;
46172   Dali::NativeImage result;
46173
46174   argp1 = (Dali::BaseHandle *)jarg1;
46175   if (!argp1) {
46176     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
46177     return 0;
46178   }
46179   arg1 = *argp1;
46180   {
46181     try {
46182       result = Dali::NativeImage::DownCast(arg1);
46183     } catch (std::out_of_range& e) {
46184       {
46185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46186       };
46187     } catch (std::exception& e) {
46188       {
46189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46190       };
46191     } catch (Dali::DaliException e) {
46192       {
46193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46194       };
46195     } catch (...) {
46196       {
46197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46198       };
46199     }
46200   }
46201
46202   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
46203   return jresult;
46204 }
46205
46206
46207 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomFragmentPreFix(void * jarg1) {
46208   char * jresult ;
46209   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46210   char *result = 0 ;
46211
46212   arg1 = (Dali::NativeImage *)jarg1;
46213   {
46214     try {
46215       result = (char *)(arg1)->GetCustomFragmentPreFix();
46216     } catch (std::out_of_range& e) {
46217       {
46218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46219       };
46220     } catch (std::exception& e) {
46221       {
46222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46223       };
46224     } catch (Dali::DaliException e) {
46225       {
46226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46227       };
46228     } catch (...) {
46229       {
46230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46231       };
46232     }
46233   }
46234
46235   jresult = SWIG_csharp_string_callback((const char *)result);
46236   return jresult;
46237 }
46238
46239
46240 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomSamplerTypename(void * jarg1) {
46241   char * jresult ;
46242   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46243   char *result = 0 ;
46244
46245   arg1 = (Dali::NativeImage *)jarg1;
46246   {
46247     try {
46248       result = (char *)(arg1)->GetCustomSamplerTypename();
46249     } catch (std::out_of_range& e) {
46250       {
46251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46252       };
46253     } catch (std::exception& e) {
46254       {
46255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46256       };
46257     } catch (Dali::DaliException e) {
46258       {
46259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46260       };
46261     } catch (...) {
46262       {
46263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46264       };
46265     }
46266   }
46267
46268   jresult = SWIG_csharp_string_callback((const char *)result);
46269   return jresult;
46270 }
46271
46272
46273 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionCreate(void * jarg1) {
46274   unsigned int jresult ;
46275   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46276   bool result;
46277
46278   arg1 = (Dali::NativeImageInterface *)jarg1;
46279   {
46280     try {
46281       result = (bool)(arg1)->GlExtensionCreate();
46282     } catch (std::out_of_range& e) {
46283       {
46284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46285       };
46286     } catch (std::exception& e) {
46287       {
46288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46289       };
46290     } catch (Dali::DaliException e) {
46291       {
46292         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46293       };
46294     } catch (...) {
46295       {
46296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46297       };
46298     }
46299   }
46300
46301   jresult = result;
46302   return jresult;
46303 }
46304
46305
46306 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionDestroy(void * jarg1) {
46307   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46308
46309   arg1 = (Dali::NativeImageInterface *)jarg1;
46310   {
46311     try {
46312       (arg1)->GlExtensionDestroy();
46313     } catch (std::out_of_range& e) {
46314       {
46315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46316       };
46317     } catch (std::exception& e) {
46318       {
46319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46320       };
46321     } catch (Dali::DaliException e) {
46322       {
46323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46324       };
46325     } catch (...) {
46326       {
46327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46328       };
46329     }
46330   }
46331
46332 }
46333
46334
46335 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_TargetTexture(void * jarg1) {
46336   unsigned int jresult ;
46337   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46338   unsigned int result;
46339
46340   arg1 = (Dali::NativeImageInterface *)jarg1;
46341   {
46342     try {
46343       result = (unsigned int)(arg1)->TargetTexture();
46344     } catch (std::out_of_range& e) {
46345       {
46346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46347       };
46348     } catch (std::exception& e) {
46349       {
46350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46351       };
46352     } catch (Dali::DaliException e) {
46353       {
46354         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46355       };
46356     } catch (...) {
46357       {
46358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46359       };
46360     }
46361   }
46362
46363   jresult = result;
46364   return jresult;
46365 }
46366
46367
46368 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_PrepareTexture(void * jarg1) {
46369   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46370
46371   arg1 = (Dali::NativeImageInterface *)jarg1;
46372   {
46373     try {
46374       (arg1)->PrepareTexture();
46375     } catch (std::out_of_range& e) {
46376       {
46377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46378       };
46379     } catch (std::exception& e) {
46380       {
46381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46382       };
46383     } catch (Dali::DaliException e) {
46384       {
46385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46386       };
46387     } catch (...) {
46388       {
46389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46390       };
46391     }
46392   }
46393
46394 }
46395
46396
46397 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetWidth(void * jarg1) {
46398   unsigned int jresult ;
46399   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46400   unsigned int result;
46401
46402   arg1 = (Dali::NativeImageInterface *)jarg1;
46403   {
46404     try {
46405       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetWidth();
46406     } catch (std::out_of_range& e) {
46407       {
46408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46409       };
46410     } catch (std::exception& e) {
46411       {
46412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46413       };
46414     } catch (Dali::DaliException e) {
46415       {
46416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46417       };
46418     } catch (...) {
46419       {
46420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46421       };
46422     }
46423   }
46424
46425   jresult = result;
46426   return jresult;
46427 }
46428
46429
46430 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetHeight(void * jarg1) {
46431   unsigned int jresult ;
46432   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46433   unsigned int result;
46434
46435   arg1 = (Dali::NativeImageInterface *)jarg1;
46436   {
46437     try {
46438       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetHeight();
46439     } catch (std::out_of_range& e) {
46440       {
46441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46442       };
46443     } catch (std::exception& e) {
46444       {
46445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46446       };
46447     } catch (Dali::DaliException e) {
46448       {
46449         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46450       };
46451     } catch (...) {
46452       {
46453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46454       };
46455     }
46456   }
46457
46458   jresult = result;
46459   return jresult;
46460 }
46461
46462
46463 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_RequiresBlending(void * jarg1) {
46464   unsigned int jresult ;
46465   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46466   bool result;
46467
46468   arg1 = (Dali::NativeImageInterface *)jarg1;
46469   {
46470     try {
46471       result = (bool)((Dali::NativeImageInterface const *)arg1)->RequiresBlending();
46472     } catch (std::out_of_range& e) {
46473       {
46474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46475       };
46476     } catch (std::exception& e) {
46477       {
46478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46479       };
46480     } catch (Dali::DaliException e) {
46481       {
46482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46483       };
46484     } catch (...) {
46485       {
46486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46487       };
46488     }
46489   }
46490
46491   jresult = result;
46492   return jresult;
46493 }
46494
46495
46496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_GetImageSize(char * jarg1) {
46497   void * jresult ;
46498   std::string *arg1 = 0 ;
46499   Dali::ImageDimensions result;
46500
46501   if (!jarg1) {
46502     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46503     return 0;
46504   }
46505   std::string arg1_str(jarg1);
46506   arg1 = &arg1_str;
46507   {
46508     try {
46509       result = Dali::ResourceImage::GetImageSize((std::string const &)*arg1);
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 = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
46530
46531   //argout typemap for const std::string&
46532
46533   return jresult;
46534 }
46535
46536
46537 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_0() {
46538   void * jresult ;
46539   Dali::ResourceImage *result = 0 ;
46540
46541   {
46542     try {
46543       result = (Dali::ResourceImage *)new Dali::ResourceImage();
46544     } catch (std::out_of_range& e) {
46545       {
46546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46547       };
46548     } catch (std::exception& e) {
46549       {
46550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46551       };
46552     } catch (Dali::DaliException e) {
46553       {
46554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46555       };
46556     } catch (...) {
46557       {
46558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46559       };
46560     }
46561   }
46562
46563   jresult = (void *)result;
46564   return jresult;
46565 }
46566
46567
46568 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImage(void * jarg1) {
46569   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
46570
46571   arg1 = (Dali::ResourceImage *)jarg1;
46572   {
46573     try {
46574       delete arg1;
46575     } catch (std::out_of_range& e) {
46576       {
46577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46578       };
46579     } catch (std::exception& e) {
46580       {
46581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46582       };
46583     } catch (Dali::DaliException e) {
46584       {
46585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46586       };
46587     } catch (...) {
46588       {
46589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46590       };
46591     }
46592   }
46593
46594 }
46595
46596
46597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_1(void * jarg1) {
46598   void * jresult ;
46599   Dali::ResourceImage *arg1 = 0 ;
46600   Dali::ResourceImage *result = 0 ;
46601
46602   arg1 = (Dali::ResourceImage *)jarg1;
46603   if (!arg1) {
46604     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
46605     return 0;
46606   }
46607   {
46608     try {
46609       result = (Dali::ResourceImage *)new Dali::ResourceImage((Dali::ResourceImage const &)*arg1);
46610     } catch (std::out_of_range& e) {
46611       {
46612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46613       };
46614     } catch (std::exception& e) {
46615       {
46616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46617       };
46618     } catch (Dali::DaliException e) {
46619       {
46620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46621       };
46622     } catch (...) {
46623       {
46624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46625       };
46626     }
46627   }
46628
46629   jresult = (void *)result;
46630   return jresult;
46631 }
46632
46633
46634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_Assign(void * jarg1, void * jarg2) {
46635   void * jresult ;
46636   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
46637   Dali::ResourceImage *arg2 = 0 ;
46638   Dali::ResourceImage *result = 0 ;
46639
46640   arg1 = (Dali::ResourceImage *)jarg1;
46641   arg2 = (Dali::ResourceImage *)jarg2;
46642   if (!arg2) {
46643     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
46644     return 0;
46645   }
46646   {
46647     try {
46648       result = (Dali::ResourceImage *) &(arg1)->operator =((Dali::ResourceImage const &)*arg2);
46649     } catch (std::out_of_range& e) {
46650       {
46651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46652       };
46653     } catch (std::exception& e) {
46654       {
46655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46656       };
46657     } catch (Dali::DaliException e) {
46658       {
46659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46660       };
46661     } catch (...) {
46662       {
46663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46664       };
46665     }
46666   }
46667
46668   jresult = (void *)result;
46669   return jresult;
46670 }
46671
46672
46673 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_0(char * jarg1, unsigned int jarg2) {
46674   void * jresult ;
46675   std::string *arg1 = 0 ;
46676   bool arg2 ;
46677   Dali::ResourceImage result;
46678
46679   if (!jarg1) {
46680     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46681     return 0;
46682   }
46683   std::string arg1_str(jarg1);
46684   arg1 = &arg1_str;
46685   arg2 = jarg2 ? true : false;
46686   {
46687     try {
46688       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
46689     } catch (std::out_of_range& e) {
46690       {
46691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46692       };
46693     } catch (std::exception& e) {
46694       {
46695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46696       };
46697     } catch (Dali::DaliException e) {
46698       {
46699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46700       };
46701     } catch (...) {
46702       {
46703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46704       };
46705     }
46706   }
46707
46708   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46709
46710   //argout typemap for const std::string&
46711
46712   return jresult;
46713 }
46714
46715
46716 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_1(char * jarg1) {
46717   void * jresult ;
46718   std::string *arg1 = 0 ;
46719   Dali::ResourceImage result;
46720
46721   if (!jarg1) {
46722     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46723     return 0;
46724   }
46725   std::string arg1_str(jarg1);
46726   arg1 = &arg1_str;
46727   {
46728     try {
46729       result = Dali::ResourceImage::New((std::string const &)*arg1);
46730     } catch (std::out_of_range& e) {
46731       {
46732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46733       };
46734     } catch (std::exception& e) {
46735       {
46736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46737       };
46738     } catch (Dali::DaliException e) {
46739       {
46740         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46741       };
46742     } catch (...) {
46743       {
46744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46745       };
46746     }
46747   }
46748
46749   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46750
46751   //argout typemap for const std::string&
46752
46753   return jresult;
46754 }
46755
46756
46757 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
46758   void * jresult ;
46759   std::string *arg1 = 0 ;
46760   Dali::ImageDimensions arg2 ;
46761   Dali::FittingMode::Type arg3 ;
46762   Dali::SamplingMode::Type arg4 ;
46763   bool arg5 ;
46764   Dali::ImageDimensions *argp2 ;
46765   Dali::ResourceImage result;
46766
46767   if (!jarg1) {
46768     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46769     return 0;
46770   }
46771   std::string arg1_str(jarg1);
46772   arg1 = &arg1_str;
46773   argp2 = (Dali::ImageDimensions *)jarg2;
46774   if (!argp2) {
46775     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46776     return 0;
46777   }
46778   arg2 = *argp2;
46779   arg3 = (Dali::FittingMode::Type)jarg3;
46780   arg4 = (Dali::SamplingMode::Type)jarg4;
46781   arg5 = jarg5 ? true : false;
46782   {
46783     try {
46784       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4,arg5);
46785     } catch (std::out_of_range& e) {
46786       {
46787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46788       };
46789     } catch (std::exception& e) {
46790       {
46791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46792       };
46793     } catch (Dali::DaliException e) {
46794       {
46795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46796       };
46797     } catch (...) {
46798       {
46799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46800       };
46801     }
46802   }
46803
46804   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46805
46806   //argout typemap for const std::string&
46807
46808   return jresult;
46809 }
46810
46811
46812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_3(char * jarg1, void * jarg2, int jarg3, int jarg4) {
46813   void * jresult ;
46814   std::string *arg1 = 0 ;
46815   Dali::ImageDimensions arg2 ;
46816   Dali::FittingMode::Type arg3 ;
46817   Dali::SamplingMode::Type arg4 ;
46818   Dali::ImageDimensions *argp2 ;
46819   Dali::ResourceImage result;
46820
46821   if (!jarg1) {
46822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46823     return 0;
46824   }
46825   std::string arg1_str(jarg1);
46826   arg1 = &arg1_str;
46827   argp2 = (Dali::ImageDimensions *)jarg2;
46828   if (!argp2) {
46829     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46830     return 0;
46831   }
46832   arg2 = *argp2;
46833   arg3 = (Dali::FittingMode::Type)jarg3;
46834   arg4 = (Dali::SamplingMode::Type)jarg4;
46835   {
46836     try {
46837       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4);
46838     } catch (std::out_of_range& e) {
46839       {
46840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46841       };
46842     } catch (std::exception& e) {
46843       {
46844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46845       };
46846     } catch (Dali::DaliException e) {
46847       {
46848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46849       };
46850     } catch (...) {
46851       {
46852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46853       };
46854     }
46855   }
46856
46857   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46858
46859   //argout typemap for const std::string&
46860
46861   return jresult;
46862 }
46863
46864
46865 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_4(char * jarg1, void * jarg2, int jarg3) {
46866   void * jresult ;
46867   std::string *arg1 = 0 ;
46868   Dali::ImageDimensions arg2 ;
46869   Dali::FittingMode::Type arg3 ;
46870   Dali::ImageDimensions *argp2 ;
46871   Dali::ResourceImage result;
46872
46873   if (!jarg1) {
46874     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46875     return 0;
46876   }
46877   std::string arg1_str(jarg1);
46878   arg1 = &arg1_str;
46879   argp2 = (Dali::ImageDimensions *)jarg2;
46880   if (!argp2) {
46881     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46882     return 0;
46883   }
46884   arg2 = *argp2;
46885   arg3 = (Dali::FittingMode::Type)jarg3;
46886   {
46887     try {
46888       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3);
46889     } catch (std::out_of_range& e) {
46890       {
46891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46892       };
46893     } catch (std::exception& e) {
46894       {
46895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46896       };
46897     } catch (Dali::DaliException e) {
46898       {
46899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46900       };
46901     } catch (...) {
46902       {
46903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46904       };
46905     }
46906   }
46907
46908   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46909
46910   //argout typemap for const std::string&
46911
46912   return jresult;
46913 }
46914
46915
46916 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_5(char * jarg1, void * jarg2) {
46917   void * jresult ;
46918   std::string *arg1 = 0 ;
46919   Dali::ImageDimensions arg2 ;
46920   Dali::ImageDimensions *argp2 ;
46921   Dali::ResourceImage result;
46922
46923   if (!jarg1) {
46924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46925     return 0;
46926   }
46927   std::string arg1_str(jarg1);
46928   arg1 = &arg1_str;
46929   argp2 = (Dali::ImageDimensions *)jarg2;
46930   if (!argp2) {
46931     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46932     return 0;
46933   }
46934   arg2 = *argp2;
46935   {
46936     try {
46937       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
46938     } catch (std::out_of_range& e) {
46939       {
46940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46941       };
46942     } catch (std::exception& e) {
46943       {
46944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46945       };
46946     } catch (Dali::DaliException e) {
46947       {
46948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46949       };
46950     } catch (...) {
46951       {
46952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46953       };
46954     }
46955   }
46956
46957   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46958
46959   //argout typemap for const std::string&
46960
46961   return jresult;
46962 }
46963
46964
46965 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_DownCast(void * jarg1) {
46966   void * jresult ;
46967   Dali::BaseHandle arg1 ;
46968   Dali::BaseHandle *argp1 ;
46969   Dali::ResourceImage result;
46970
46971   argp1 = (Dali::BaseHandle *)jarg1;
46972   if (!argp1) {
46973     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
46974     return 0;
46975   }
46976   arg1 = *argp1;
46977   {
46978     try {
46979       result = Dali::ResourceImage::DownCast(arg1);
46980     } catch (std::out_of_range& e) {
46981       {
46982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46983       };
46984     } catch (std::exception& e) {
46985       {
46986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46987       };
46988     } catch (Dali::DaliException e) {
46989       {
46990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46991       };
46992     } catch (...) {
46993       {
46994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46995       };
46996     }
46997   }
46998
46999   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
47000   return jresult;
47001 }
47002
47003
47004 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResourceImage_GetLoadingState(void * jarg1) {
47005   int jresult ;
47006   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
47007   Dali::LoadingState result;
47008
47009   arg1 = (Dali::ResourceImage *)jarg1;
47010   {
47011     try {
47012       result = (Dali::LoadingState)((Dali::ResourceImage const *)arg1)->GetLoadingState();
47013     } catch (std::out_of_range& e) {
47014       {
47015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47016       };
47017     } catch (std::exception& e) {
47018       {
47019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47020       };
47021     } catch (Dali::DaliException e) {
47022       {
47023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47024       };
47025     } catch (...) {
47026       {
47027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47028       };
47029     }
47030   }
47031
47032   jresult = (int)result;
47033   return jresult;
47034 }
47035
47036
47037 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ResourceImage_GetUrl(void * jarg1) {
47038   char * jresult ;
47039   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
47040   std::string result;
47041
47042   arg1 = (Dali::ResourceImage *)jarg1;
47043   {
47044     try {
47045       result = ((Dali::ResourceImage const *)arg1)->GetUrl();
47046     } catch (std::out_of_range& e) {
47047       {
47048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47049       };
47050     } catch (std::exception& e) {
47051       {
47052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47053       };
47054     } catch (Dali::DaliException e) {
47055       {
47056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47057       };
47058     } catch (...) {
47059       {
47060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47061       };
47062     }
47063   }
47064
47065   jresult = SWIG_csharp_string_callback((&result)->c_str());
47066   return jresult;
47067 }
47068
47069
47070 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImage_Reload(void * jarg1) {
47071   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
47072
47073   arg1 = (Dali::ResourceImage *)jarg1;
47074   {
47075     try {
47076       (arg1)->Reload();
47077     } catch (std::out_of_range& e) {
47078       {
47079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47080       };
47081     } catch (std::exception& e) {
47082       {
47083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47084       };
47085     } catch (Dali::DaliException e) {
47086       {
47087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47088       };
47089     } catch (...) {
47090       {
47091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47092       };
47093     }
47094   }
47095
47096 }
47097
47098
47099 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_LoadingFinishedSignal(void * jarg1) {
47100   void * jresult ;
47101   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
47102   Dali::ResourceImage::ResourceImageSignal *result = 0 ;
47103
47104   arg1 = (Dali::ResourceImage *)jarg1;
47105   {
47106     try {
47107       result = (Dali::ResourceImage::ResourceImageSignal *) &(arg1)->LoadingFinishedSignal();
47108     } catch (std::out_of_range& e) {
47109       {
47110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47111       };
47112     } catch (std::exception& e) {
47113       {
47114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47115       };
47116     } catch (Dali::DaliException e) {
47117       {
47118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47119       };
47120     } catch (...) {
47121       {
47122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47123       };
47124     }
47125   }
47126
47127   jresult = (void *)result;
47128   return jresult;
47129 }
47130
47131
47132 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_0() {
47133   void * jresult ;
47134   Dali::FrameBufferImage *result = 0 ;
47135
47136   {
47137     try {
47138       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage();
47139     } catch (std::out_of_range& e) {
47140       {
47141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47142       };
47143     } catch (std::exception& e) {
47144       {
47145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47146       };
47147     } catch (Dali::DaliException e) {
47148       {
47149         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47150       };
47151     } catch (...) {
47152       {
47153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47154       };
47155     }
47156   }
47157
47158   jresult = (void *)result;
47159   return jresult;
47160 }
47161
47162
47163 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3, int jarg4) {
47164   void * jresult ;
47165   unsigned int arg1 ;
47166   unsigned int arg2 ;
47167   Dali::Pixel::Format arg3 ;
47168   Dali::RenderBuffer::Format arg4 ;
47169   Dali::FrameBufferImage result;
47170
47171   arg1 = (unsigned int)jarg1;
47172   arg2 = (unsigned int)jarg2;
47173   arg3 = (Dali::Pixel::Format)jarg3;
47174   arg4 = (Dali::RenderBuffer::Format)jarg4;
47175   {
47176     try {
47177       result = Dali::FrameBufferImage::New(arg1,arg2,arg3,arg4);
47178     } catch (std::out_of_range& e) {
47179       {
47180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47181       };
47182     } catch (std::exception& e) {
47183       {
47184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47185       };
47186     } catch (Dali::DaliException e) {
47187       {
47188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47189       };
47190     } catch (...) {
47191       {
47192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47193       };
47194     }
47195   }
47196
47197   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47198   return jresult;
47199 }
47200
47201
47202 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2, int jarg3) {
47203   void * jresult ;
47204   unsigned int arg1 ;
47205   unsigned int arg2 ;
47206   Dali::Pixel::Format arg3 ;
47207   Dali::FrameBufferImage result;
47208
47209   arg1 = (unsigned int)jarg1;
47210   arg2 = (unsigned int)jarg2;
47211   arg3 = (Dali::Pixel::Format)jarg3;
47212   {
47213     try {
47214       result = Dali::FrameBufferImage::New(arg1,arg2,arg3);
47215     } catch (std::out_of_range& e) {
47216       {
47217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47218       };
47219     } catch (std::exception& e) {
47220       {
47221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47222       };
47223     } catch (Dali::DaliException e) {
47224       {
47225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47226       };
47227     } catch (...) {
47228       {
47229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47230       };
47231     }
47232   }
47233
47234   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47235   return jresult;
47236 }
47237
47238
47239 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
47240   void * jresult ;
47241   unsigned int arg1 ;
47242   unsigned int arg2 ;
47243   Dali::FrameBufferImage result;
47244
47245   arg1 = (unsigned int)jarg1;
47246   arg2 = (unsigned int)jarg2;
47247   {
47248     try {
47249       result = Dali::FrameBufferImage::New(arg1,arg2);
47250     } catch (std::out_of_range& e) {
47251       {
47252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47253       };
47254     } catch (std::exception& e) {
47255       {
47256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47257       };
47258     } catch (Dali::DaliException e) {
47259       {
47260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47261       };
47262     } catch (...) {
47263       {
47264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47265       };
47266     }
47267   }
47268
47269   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47270   return jresult;
47271 }
47272
47273
47274 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_3(unsigned int jarg1) {
47275   void * jresult ;
47276   unsigned int arg1 ;
47277   Dali::FrameBufferImage result;
47278
47279   arg1 = (unsigned int)jarg1;
47280   {
47281     try {
47282       result = Dali::FrameBufferImage::New(arg1);
47283     } catch (std::out_of_range& e) {
47284       {
47285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47286       };
47287     } catch (std::exception& e) {
47288       {
47289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47290       };
47291     } catch (Dali::DaliException e) {
47292       {
47293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47294       };
47295     } catch (...) {
47296       {
47297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47298       };
47299     }
47300   }
47301
47302   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47303   return jresult;
47304 }
47305
47306
47307 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_4() {
47308   void * jresult ;
47309   Dali::FrameBufferImage result;
47310
47311   {
47312     try {
47313       result = Dali::FrameBufferImage::New();
47314     } catch (std::out_of_range& e) {
47315       {
47316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47317       };
47318     } catch (std::exception& e) {
47319       {
47320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47321       };
47322     } catch (Dali::DaliException e) {
47323       {
47324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47325       };
47326     } catch (...) {
47327       {
47328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47329       };
47330     }
47331   }
47332
47333   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47334   return jresult;
47335 }
47336
47337
47338 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_5(void * jarg1) {
47339   void * jresult ;
47340   Dali::NativeImageInterface *arg1 = 0 ;
47341   Dali::FrameBufferImage result;
47342
47343   arg1 = (Dali::NativeImageInterface *)jarg1;
47344   if (!arg1) {
47345     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImageInterface & type is null", 0);
47346     return 0;
47347   }
47348   {
47349     try {
47350       result = Dali::FrameBufferImage::New(*arg1);
47351     } catch (std::out_of_range& e) {
47352       {
47353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47354       };
47355     } catch (std::exception& e) {
47356       {
47357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47358       };
47359     } catch (Dali::DaliException e) {
47360       {
47361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47362       };
47363     } catch (...) {
47364       {
47365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47366       };
47367     }
47368   }
47369
47370   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47371   return jresult;
47372 }
47373
47374
47375 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_DownCast(void * jarg1) {
47376   void * jresult ;
47377   Dali::BaseHandle arg1 ;
47378   Dali::BaseHandle *argp1 ;
47379   Dali::FrameBufferImage result;
47380
47381   argp1 = (Dali::BaseHandle *)jarg1;
47382   if (!argp1) {
47383     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
47384     return 0;
47385   }
47386   arg1 = *argp1;
47387   {
47388     try {
47389       result = Dali::FrameBufferImage::DownCast(arg1);
47390     } catch (std::out_of_range& e) {
47391       {
47392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47393       };
47394     } catch (std::exception& e) {
47395       {
47396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47397       };
47398     } catch (Dali::DaliException e) {
47399       {
47400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47401       };
47402     } catch (...) {
47403       {
47404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47405       };
47406     }
47407   }
47408
47409   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47410   return jresult;
47411 }
47412
47413
47414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBufferImage(void * jarg1) {
47415   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
47416
47417   arg1 = (Dali::FrameBufferImage *)jarg1;
47418   {
47419     try {
47420       delete arg1;
47421     } catch (std::out_of_range& e) {
47422       {
47423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47424       };
47425     } catch (std::exception& e) {
47426       {
47427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47428       };
47429     } catch (Dali::DaliException e) {
47430       {
47431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47432       };
47433     } catch (...) {
47434       {
47435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47436       };
47437     }
47438   }
47439
47440 }
47441
47442
47443 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_1(void * jarg1) {
47444   void * jresult ;
47445   Dali::FrameBufferImage *arg1 = 0 ;
47446   Dali::FrameBufferImage *result = 0 ;
47447
47448   arg1 = (Dali::FrameBufferImage *)jarg1;
47449   if (!arg1) {
47450     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
47451     return 0;
47452   }
47453   {
47454     try {
47455       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage((Dali::FrameBufferImage const &)*arg1);
47456     } catch (std::out_of_range& e) {
47457       {
47458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47459       };
47460     } catch (std::exception& e) {
47461       {
47462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47463       };
47464     } catch (Dali::DaliException e) {
47465       {
47466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47467       };
47468     } catch (...) {
47469       {
47470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47471       };
47472     }
47473   }
47474
47475   jresult = (void *)result;
47476   return jresult;
47477 }
47478
47479
47480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_Assign(void * jarg1, void * jarg2) {
47481   void * jresult ;
47482   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
47483   Dali::FrameBufferImage *arg2 = 0 ;
47484   Dali::FrameBufferImage *result = 0 ;
47485
47486   arg1 = (Dali::FrameBufferImage *)jarg1;
47487   arg2 = (Dali::FrameBufferImage *)jarg2;
47488   if (!arg2) {
47489     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
47490     return 0;
47491   }
47492   {
47493     try {
47494       result = (Dali::FrameBufferImage *) &(arg1)->operator =((Dali::FrameBufferImage const &)*arg2);
47495     } catch (std::out_of_range& e) {
47496       {
47497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47498       };
47499     } catch (std::exception& e) {
47500       {
47501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47502       };
47503     } catch (Dali::DaliException e) {
47504       {
47505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47506       };
47507     } catch (...) {
47508       {
47509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47510       };
47511     }
47512   }
47513
47514   jresult = (void *)result;
47515   return jresult;
47516 }
47517
47518
47519 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NinePatchImage__SWIG_0() {
47520   void * jresult ;
47521   Dali::NinePatchImage *result = 0 ;
47522
47523   {
47524     try {
47525       result = (Dali::NinePatchImage *)new Dali::NinePatchImage();
47526     } catch (std::out_of_range& e) {
47527       {
47528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47529       };
47530     } catch (std::exception& e) {
47531       {
47532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47533       };
47534     } catch (Dali::DaliException e) {
47535       {
47536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47537       };
47538     } catch (...) {
47539       {
47540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47541       };
47542     }
47543   }
47544
47545   jresult = (void *)result;
47546   return jresult;
47547 }
47548
47549
47550 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_New(char * jarg1) {
47551   void * jresult ;
47552   std::string *arg1 = 0 ;
47553   Dali::NinePatchImage result;
47554
47555   if (!jarg1) {
47556     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
47557     return 0;
47558   }
47559   std::string arg1_str(jarg1);
47560   arg1 = &arg1_str;
47561   {
47562     try {
47563       result = Dali::NinePatchImage::New((std::string const &)*arg1);
47564     } catch (std::out_of_range& e) {
47565       {
47566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47567       };
47568     } catch (std::exception& e) {
47569       {
47570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47571       };
47572     } catch (Dali::DaliException e) {
47573       {
47574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47575       };
47576     } catch (...) {
47577       {
47578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47579       };
47580     }
47581   }
47582
47583   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
47584
47585   //argout typemap for const std::string&
47586
47587   return jresult;
47588 }
47589
47590
47591 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_DownCast(void * jarg1) {
47592   void * jresult ;
47593   Dali::BaseHandle arg1 ;
47594   Dali::BaseHandle *argp1 ;
47595   Dali::NinePatchImage result;
47596
47597   argp1 = (Dali::BaseHandle *)jarg1;
47598   if (!argp1) {
47599     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
47600     return 0;
47601   }
47602   arg1 = *argp1;
47603   {
47604     try {
47605       result = Dali::NinePatchImage::DownCast(arg1);
47606     } catch (std::out_of_range& e) {
47607       {
47608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47609       };
47610     } catch (std::exception& e) {
47611       {
47612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47613       };
47614     } catch (Dali::DaliException e) {
47615       {
47616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47617       };
47618     } catch (...) {
47619       {
47620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47621       };
47622     }
47623   }
47624
47625   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
47626   return jresult;
47627 }
47628
47629
47630 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NinePatchImage(void * jarg1) {
47631   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47632
47633   arg1 = (Dali::NinePatchImage *)jarg1;
47634   {
47635     try {
47636       delete arg1;
47637     } catch (std::out_of_range& e) {
47638       {
47639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47640       };
47641     } catch (std::exception& e) {
47642       {
47643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47644       };
47645     } catch (Dali::DaliException e) {
47646       {
47647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47648       };
47649     } catch (...) {
47650       {
47651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47652       };
47653     }
47654   }
47655
47656 }
47657
47658
47659 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NinePatchImage__SWIG_1(void * jarg1) {
47660   void * jresult ;
47661   Dali::NinePatchImage *arg1 = 0 ;
47662   Dali::NinePatchImage *result = 0 ;
47663
47664   arg1 = (Dali::NinePatchImage *)jarg1;
47665   if (!arg1) {
47666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
47667     return 0;
47668   }
47669   {
47670     try {
47671       result = (Dali::NinePatchImage *)new Dali::NinePatchImage((Dali::NinePatchImage const &)*arg1);
47672     } catch (std::out_of_range& e) {
47673       {
47674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47675       };
47676     } catch (std::exception& e) {
47677       {
47678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47679       };
47680     } catch (Dali::DaliException e) {
47681       {
47682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47683       };
47684     } catch (...) {
47685       {
47686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47687       };
47688     }
47689   }
47690
47691   jresult = (void *)result;
47692   return jresult;
47693 }
47694
47695
47696 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_Assign(void * jarg1, void * jarg2) {
47697   void * jresult ;
47698   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47699   Dali::NinePatchImage *arg2 = 0 ;
47700   Dali::NinePatchImage *result = 0 ;
47701
47702   arg1 = (Dali::NinePatchImage *)jarg1;
47703   arg2 = (Dali::NinePatchImage *)jarg2;
47704   if (!arg2) {
47705     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
47706     return 0;
47707   }
47708   {
47709     try {
47710       result = (Dali::NinePatchImage *) &(arg1)->operator =((Dali::NinePatchImage const &)*arg2);
47711     } catch (std::out_of_range& e) {
47712       {
47713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47714       };
47715     } catch (std::exception& e) {
47716       {
47717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47718       };
47719     } catch (Dali::DaliException e) {
47720       {
47721         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47722       };
47723     } catch (...) {
47724       {
47725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47726       };
47727     }
47728   }
47729
47730   jresult = (void *)result;
47731   return jresult;
47732 }
47733
47734
47735 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchBorders(void * jarg1) {
47736   void * jresult ;
47737   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47738   Dali::Vector4 result;
47739
47740   arg1 = (Dali::NinePatchImage *)jarg1;
47741   {
47742     try {
47743       result = (arg1)->GetStretchBorders();
47744     } catch (std::out_of_range& e) {
47745       {
47746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47747       };
47748     } catch (std::exception& e) {
47749       {
47750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47751       };
47752     } catch (Dali::DaliException e) {
47753       {
47754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47755       };
47756     } catch (...) {
47757       {
47758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47759       };
47760     }
47761   }
47762
47763   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
47764   return jresult;
47765 }
47766
47767
47768 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsX(void * jarg1) {
47769   void * jresult ;
47770   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47771   Dali::NinePatchImage::StretchRanges *result = 0 ;
47772
47773   arg1 = (Dali::NinePatchImage *)jarg1;
47774   {
47775     try {
47776       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsX();
47777     } catch (std::out_of_range& e) {
47778       {
47779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47780       };
47781     } catch (std::exception& e) {
47782       {
47783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47784       };
47785     } catch (Dali::DaliException e) {
47786       {
47787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47788       };
47789     } catch (...) {
47790       {
47791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47792       };
47793     }
47794   }
47795
47796   jresult = (void *)result;
47797   return jresult;
47798 }
47799
47800
47801 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsY(void * jarg1) {
47802   void * jresult ;
47803   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47804   Dali::NinePatchImage::StretchRanges *result = 0 ;
47805
47806   arg1 = (Dali::NinePatchImage *)jarg1;
47807   {
47808     try {
47809       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsY();
47810     } catch (std::out_of_range& e) {
47811       {
47812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47813       };
47814     } catch (std::exception& e) {
47815       {
47816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47817       };
47818     } catch (Dali::DaliException e) {
47819       {
47820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47821       };
47822     } catch (...) {
47823       {
47824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47825       };
47826     }
47827   }
47828
47829   jresult = (void *)result;
47830   return jresult;
47831 }
47832
47833
47834 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetChildRectangle(void * jarg1) {
47835   void * jresult ;
47836   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47837   Dali::Rect< int > result;
47838
47839   arg1 = (Dali::NinePatchImage *)jarg1;
47840   {
47841     try {
47842       result = (arg1)->GetChildRectangle();
47843     } catch (std::out_of_range& e) {
47844       {
47845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47846       };
47847     } catch (std::exception& e) {
47848       {
47849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47850       };
47851     } catch (Dali::DaliException e) {
47852       {
47853         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47854       };
47855     } catch (...) {
47856       {
47857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47858       };
47859     }
47860   }
47861
47862   jresult = new Dali::Rect< int >((const Dali::Rect< int > &)result);
47863   return jresult;
47864 }
47865
47866
47867 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_CreateCroppedBufferImage(void * jarg1) {
47868   void * jresult ;
47869   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47870   Dali::BufferImage result;
47871
47872   arg1 = (Dali::NinePatchImage *)jarg1;
47873   {
47874     try {
47875       result = (arg1)->CreateCroppedBufferImage();
47876     } catch (std::out_of_range& e) {
47877       {
47878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47879       };
47880     } catch (std::exception& e) {
47881       {
47882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47883       };
47884     } catch (Dali::DaliException e) {
47885       {
47886         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47887       };
47888     } catch (...) {
47889       {
47890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47891       };
47892     }
47893   }
47894
47895   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
47896   return jresult;
47897 }
47898
47899
47900 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NinePatchImage_IsNinePatchUrl(char * jarg1) {
47901   unsigned int jresult ;
47902   std::string *arg1 = 0 ;
47903   bool result;
47904
47905   if (!jarg1) {
47906     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
47907     return 0;
47908   }
47909   std::string arg1_str(jarg1);
47910   arg1 = &arg1_str;
47911   {
47912     try {
47913       result = (bool)Dali::NinePatchImage::IsNinePatchUrl((std::string const &)*arg1);
47914     } catch (std::out_of_range& e) {
47915       {
47916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47917       };
47918     } catch (std::exception& e) {
47919       {
47920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47921       };
47922     } catch (Dali::DaliException e) {
47923       {
47924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47925       };
47926     } catch (...) {
47927       {
47928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47929       };
47930     }
47931   }
47932
47933   jresult = result;
47934
47935   //argout typemap for const std::string&
47936
47937   return jresult;
47938 }
47939
47940
47941 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TYPE_get() {
47942   int jresult ;
47943   int result;
47944
47945   result = (int)Dali::CameraActor::Property::TYPE;
47946   jresult = (int)result;
47947   return jresult;
47948 }
47949
47950
47951 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MODE_get() {
47952   int jresult ;
47953   int result;
47954
47955   result = (int)Dali::CameraActor::Property::PROJECTION_MODE;
47956   jresult = (int)result;
47957   return jresult;
47958 }
47959
47960
47961 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FIELD_OF_VIEW_get() {
47962   int jresult ;
47963   int result;
47964
47965   result = (int)Dali::CameraActor::Property::FIELD_OF_VIEW;
47966   jresult = (int)result;
47967   return jresult;
47968 }
47969
47970
47971 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_ASPECT_RATIO_get() {
47972   int jresult ;
47973   int result;
47974
47975   result = (int)Dali::CameraActor::Property::ASPECT_RATIO;
47976   jresult = (int)result;
47977   return jresult;
47978 }
47979
47980
47981 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_NEAR_PLANE_DISTANCE_get() {
47982   int jresult ;
47983   int result;
47984
47985   result = (int)Dali::CameraActor::Property::NEAR_PLANE_DISTANCE;
47986   jresult = (int)result;
47987   return jresult;
47988 }
47989
47990
47991 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FAR_PLANE_DISTANCE_get() {
47992   int jresult ;
47993   int result;
47994
47995   result = (int)Dali::CameraActor::Property::FAR_PLANE_DISTANCE;
47996   jresult = (int)result;
47997   return jresult;
47998 }
47999
48000
48001 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_LEFT_PLANE_DISTANCE_get() {
48002   int jresult ;
48003   int result;
48004
48005   result = (int)Dali::CameraActor::Property::LEFT_PLANE_DISTANCE;
48006   jresult = (int)result;
48007   return jresult;
48008 }
48009
48010
48011 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_RIGHT_PLANE_DISTANCE_get() {
48012   int jresult ;
48013   int result;
48014
48015   result = (int)Dali::CameraActor::Property::RIGHT_PLANE_DISTANCE;
48016   jresult = (int)result;
48017   return jresult;
48018 }
48019
48020
48021 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TOP_PLANE_DISTANCE_get() {
48022   int jresult ;
48023   int result;
48024
48025   result = (int)Dali::CameraActor::Property::TOP_PLANE_DISTANCE;
48026   jresult = (int)result;
48027   return jresult;
48028 }
48029
48030
48031 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_BOTTOM_PLANE_DISTANCE_get() {
48032   int jresult ;
48033   int result;
48034
48035   result = (int)Dali::CameraActor::Property::BOTTOM_PLANE_DISTANCE;
48036   jresult = (int)result;
48037   return jresult;
48038 }
48039
48040
48041 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TARGET_POSITION_get() {
48042   int jresult ;
48043   int result;
48044
48045   result = (int)Dali::CameraActor::Property::TARGET_POSITION;
48046   jresult = (int)result;
48047   return jresult;
48048 }
48049
48050
48051 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MATRIX_get() {
48052   int jresult ;
48053   int result;
48054
48055   result = (int)Dali::CameraActor::Property::PROJECTION_MATRIX;
48056   jresult = (int)result;
48057   return jresult;
48058 }
48059
48060
48061 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_VIEW_MATRIX_get() {
48062   int jresult ;
48063   int result;
48064
48065   result = (int)Dali::CameraActor::Property::VIEW_MATRIX;
48066   jresult = (int)result;
48067   return jresult;
48068 }
48069
48070
48071 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_INVERT_Y_AXIS_get() {
48072   int jresult ;
48073   int result;
48074
48075   result = (int)Dali::CameraActor::Property::INVERT_Y_AXIS;
48076   jresult = (int)result;
48077   return jresult;
48078 }
48079
48080
48081 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor_Property() {
48082   void * jresult ;
48083   Dali::CameraActor::Property *result = 0 ;
48084
48085   {
48086     try {
48087       result = (Dali::CameraActor::Property *)new Dali::CameraActor::Property();
48088     } catch (std::out_of_range& e) {
48089       {
48090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48091       };
48092     } catch (std::exception& e) {
48093       {
48094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48095       };
48096     } catch (Dali::DaliException e) {
48097       {
48098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48099       };
48100     } catch (...) {
48101       {
48102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48103       };
48104     }
48105   }
48106
48107   jresult = (void *)result;
48108   return jresult;
48109 }
48110
48111
48112 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor_Property(void * jarg1) {
48113   Dali::CameraActor::Property *arg1 = (Dali::CameraActor::Property *) 0 ;
48114
48115   arg1 = (Dali::CameraActor::Property *)jarg1;
48116   {
48117     try {
48118       delete arg1;
48119     } catch (std::out_of_range& e) {
48120       {
48121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48122       };
48123     } catch (std::exception& e) {
48124       {
48125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48126       };
48127     } catch (Dali::DaliException e) {
48128       {
48129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48130       };
48131     } catch (...) {
48132       {
48133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48134       };
48135     }
48136   }
48137
48138 }
48139
48140
48141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_0() {
48142   void * jresult ;
48143   Dali::CameraActor *result = 0 ;
48144
48145   {
48146     try {
48147       result = (Dali::CameraActor *)new Dali::CameraActor();
48148     } catch (std::out_of_range& e) {
48149       {
48150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48151       };
48152     } catch (std::exception& e) {
48153       {
48154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48155       };
48156     } catch (Dali::DaliException e) {
48157       {
48158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48159       };
48160     } catch (...) {
48161       {
48162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48163       };
48164     }
48165   }
48166
48167   jresult = (void *)result;
48168   return jresult;
48169 }
48170
48171
48172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_0() {
48173   void * jresult ;
48174   Dali::CameraActor result;
48175
48176   {
48177     try {
48178       result = Dali::CameraActor::New();
48179     } catch (std::out_of_range& e) {
48180       {
48181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48182       };
48183     } catch (std::exception& e) {
48184       {
48185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48186       };
48187     } catch (Dali::DaliException e) {
48188       {
48189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48190       };
48191     } catch (...) {
48192       {
48193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48194       };
48195     }
48196   }
48197
48198   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
48199   return jresult;
48200 }
48201
48202
48203 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_1(void * jarg1) {
48204   void * jresult ;
48205   Dali::Size *arg1 = 0 ;
48206   Dali::CameraActor result;
48207
48208   arg1 = (Dali::Size *)jarg1;
48209   if (!arg1) {
48210     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
48211     return 0;
48212   }
48213   {
48214     try {
48215       result = Dali::CameraActor::New((Dali::Vector2 const &)*arg1);
48216     } catch (std::out_of_range& e) {
48217       {
48218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48219       };
48220     } catch (std::exception& e) {
48221       {
48222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48223       };
48224     } catch (Dali::DaliException e) {
48225       {
48226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48227       };
48228     } catch (...) {
48229       {
48230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48231       };
48232     }
48233   }
48234
48235   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
48236   return jresult;
48237 }
48238
48239
48240 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_DownCast(void * jarg1) {
48241   void * jresult ;
48242   Dali::BaseHandle arg1 ;
48243   Dali::BaseHandle *argp1 ;
48244   Dali::CameraActor result;
48245
48246   argp1 = (Dali::BaseHandle *)jarg1;
48247   if (!argp1) {
48248     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
48249     return 0;
48250   }
48251   arg1 = *argp1;
48252   {
48253     try {
48254       result = Dali::CameraActor::DownCast(arg1);
48255     } catch (std::out_of_range& e) {
48256       {
48257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48258       };
48259     } catch (std::exception& e) {
48260       {
48261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48262       };
48263     } catch (Dali::DaliException e) {
48264       {
48265         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48266       };
48267     } catch (...) {
48268       {
48269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48270       };
48271     }
48272   }
48273
48274   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
48275   return jresult;
48276 }
48277
48278
48279 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor(void * jarg1) {
48280   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48281
48282   arg1 = (Dali::CameraActor *)jarg1;
48283   {
48284     try {
48285       delete arg1;
48286     } catch (std::out_of_range& e) {
48287       {
48288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48289       };
48290     } catch (std::exception& e) {
48291       {
48292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48293       };
48294     } catch (Dali::DaliException e) {
48295       {
48296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48297       };
48298     } catch (...) {
48299       {
48300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48301       };
48302     }
48303   }
48304
48305 }
48306
48307
48308 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_1(void * jarg1) {
48309   void * jresult ;
48310   Dali::CameraActor *arg1 = 0 ;
48311   Dali::CameraActor *result = 0 ;
48312
48313   arg1 = (Dali::CameraActor *)jarg1;
48314   if (!arg1) {
48315     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
48316     return 0;
48317   }
48318   {
48319     try {
48320       result = (Dali::CameraActor *)new Dali::CameraActor((Dali::CameraActor const &)*arg1);
48321     } catch (std::out_of_range& e) {
48322       {
48323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48324       };
48325     } catch (std::exception& e) {
48326       {
48327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48328       };
48329     } catch (Dali::DaliException e) {
48330       {
48331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48332       };
48333     } catch (...) {
48334       {
48335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48336       };
48337     }
48338   }
48339
48340   jresult = (void *)result;
48341   return jresult;
48342 }
48343
48344
48345 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_Assign(void * jarg1, void * jarg2) {
48346   void * jresult ;
48347   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48348   Dali::CameraActor *arg2 = 0 ;
48349   Dali::CameraActor *result = 0 ;
48350
48351   arg1 = (Dali::CameraActor *)jarg1;
48352   arg2 = (Dali::CameraActor *)jarg2;
48353   if (!arg2) {
48354     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
48355     return 0;
48356   }
48357   {
48358     try {
48359       result = (Dali::CameraActor *) &(arg1)->operator =((Dali::CameraActor const &)*arg2);
48360     } catch (std::out_of_range& e) {
48361       {
48362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48363       };
48364     } catch (std::exception& e) {
48365       {
48366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48367       };
48368     } catch (Dali::DaliException e) {
48369       {
48370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48371       };
48372     } catch (...) {
48373       {
48374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48375       };
48376     }
48377   }
48378
48379   jresult = (void *)result;
48380   return jresult;
48381 }
48382
48383
48384 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetType(void * jarg1, int jarg2) {
48385   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48386   Dali::Camera::Type arg2 ;
48387
48388   arg1 = (Dali::CameraActor *)jarg1;
48389   arg2 = (Dali::Camera::Type)jarg2;
48390   {
48391     try {
48392       (arg1)->SetType(arg2);
48393     } catch (std::out_of_range& e) {
48394       {
48395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48396       };
48397     } catch (std::exception& e) {
48398       {
48399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48400       };
48401     } catch (Dali::DaliException e) {
48402       {
48403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48404       };
48405     } catch (...) {
48406       {
48407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48408       };
48409     }
48410   }
48411
48412 }
48413
48414
48415 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetType(void * jarg1) {
48416   int jresult ;
48417   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48418   Dali::Camera::Type result;
48419
48420   arg1 = (Dali::CameraActor *)jarg1;
48421   {
48422     try {
48423       result = (Dali::Camera::Type)((Dali::CameraActor const *)arg1)->GetType();
48424     } catch (std::out_of_range& e) {
48425       {
48426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48427       };
48428     } catch (std::exception& e) {
48429       {
48430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48431       };
48432     } catch (Dali::DaliException e) {
48433       {
48434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48435       };
48436     } catch (...) {
48437       {
48438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48439       };
48440     }
48441   }
48442
48443   jresult = (int)result;
48444   return jresult;
48445 }
48446
48447
48448 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetProjectionMode(void * jarg1, int jarg2) {
48449   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48450   Dali::Camera::ProjectionMode arg2 ;
48451
48452   arg1 = (Dali::CameraActor *)jarg1;
48453   arg2 = (Dali::Camera::ProjectionMode)jarg2;
48454   {
48455     try {
48456       (arg1)->SetProjectionMode(arg2);
48457     } catch (std::out_of_range& e) {
48458       {
48459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48460       };
48461     } catch (std::exception& e) {
48462       {
48463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48464       };
48465     } catch (Dali::DaliException e) {
48466       {
48467         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48468       };
48469     } catch (...) {
48470       {
48471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48472       };
48473     }
48474   }
48475
48476 }
48477
48478
48479 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetProjectionMode(void * jarg1) {
48480   int jresult ;
48481   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48482   Dali::Camera::ProjectionMode result;
48483
48484   arg1 = (Dali::CameraActor *)jarg1;
48485   {
48486     try {
48487       result = (Dali::Camera::ProjectionMode)((Dali::CameraActor const *)arg1)->GetProjectionMode();
48488     } catch (std::out_of_range& e) {
48489       {
48490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48491       };
48492     } catch (std::exception& e) {
48493       {
48494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48495       };
48496     } catch (Dali::DaliException e) {
48497       {
48498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48499       };
48500     } catch (...) {
48501       {
48502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48503       };
48504     }
48505   }
48506
48507   jresult = (int)result;
48508   return jresult;
48509 }
48510
48511
48512 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFieldOfView(void * jarg1, float jarg2) {
48513   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48514   float arg2 ;
48515
48516   arg1 = (Dali::CameraActor *)jarg1;
48517   arg2 = (float)jarg2;
48518   {
48519     try {
48520       (arg1)->SetFieldOfView(arg2);
48521     } catch (std::out_of_range& e) {
48522       {
48523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48524       };
48525     } catch (std::exception& e) {
48526       {
48527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48528       };
48529     } catch (Dali::DaliException e) {
48530       {
48531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48532       };
48533     } catch (...) {
48534       {
48535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48536       };
48537     }
48538   }
48539
48540 }
48541
48542
48543 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFieldOfView(void * jarg1) {
48544   float jresult ;
48545   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48546   float result;
48547
48548   arg1 = (Dali::CameraActor *)jarg1;
48549   {
48550     try {
48551       result = (float)(arg1)->GetFieldOfView();
48552     } catch (std::out_of_range& e) {
48553       {
48554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48555       };
48556     } catch (std::exception& e) {
48557       {
48558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48559       };
48560     } catch (Dali::DaliException e) {
48561       {
48562         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48563       };
48564     } catch (...) {
48565       {
48566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48567       };
48568     }
48569   }
48570
48571   jresult = result;
48572   return jresult;
48573 }
48574
48575
48576 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetAspectRatio(void * jarg1, float jarg2) {
48577   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48578   float arg2 ;
48579
48580   arg1 = (Dali::CameraActor *)jarg1;
48581   arg2 = (float)jarg2;
48582   {
48583     try {
48584       (arg1)->SetAspectRatio(arg2);
48585     } catch (std::out_of_range& e) {
48586       {
48587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48588       };
48589     } catch (std::exception& e) {
48590       {
48591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48592       };
48593     } catch (Dali::DaliException e) {
48594       {
48595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48596       };
48597     } catch (...) {
48598       {
48599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48600       };
48601     }
48602   }
48603
48604 }
48605
48606
48607 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetAspectRatio(void * jarg1) {
48608   float jresult ;
48609   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48610   float result;
48611
48612   arg1 = (Dali::CameraActor *)jarg1;
48613   {
48614     try {
48615       result = (float)(arg1)->GetAspectRatio();
48616     } catch (std::out_of_range& e) {
48617       {
48618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48619       };
48620     } catch (std::exception& e) {
48621       {
48622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48623       };
48624     } catch (Dali::DaliException e) {
48625       {
48626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48627       };
48628     } catch (...) {
48629       {
48630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48631       };
48632     }
48633   }
48634
48635   jresult = result;
48636   return jresult;
48637 }
48638
48639
48640 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetNearClippingPlane(void * jarg1, float jarg2) {
48641   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48642   float arg2 ;
48643
48644   arg1 = (Dali::CameraActor *)jarg1;
48645   arg2 = (float)jarg2;
48646   {
48647     try {
48648       (arg1)->SetNearClippingPlane(arg2);
48649     } catch (std::out_of_range& e) {
48650       {
48651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48652       };
48653     } catch (std::exception& e) {
48654       {
48655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48656       };
48657     } catch (Dali::DaliException e) {
48658       {
48659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48660       };
48661     } catch (...) {
48662       {
48663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48664       };
48665     }
48666   }
48667
48668 }
48669
48670
48671 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetNearClippingPlane(void * jarg1) {
48672   float jresult ;
48673   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48674   float result;
48675
48676   arg1 = (Dali::CameraActor *)jarg1;
48677   {
48678     try {
48679       result = (float)(arg1)->GetNearClippingPlane();
48680     } catch (std::out_of_range& e) {
48681       {
48682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48683       };
48684     } catch (std::exception& e) {
48685       {
48686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48687       };
48688     } catch (Dali::DaliException e) {
48689       {
48690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48691       };
48692     } catch (...) {
48693       {
48694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48695       };
48696     }
48697   }
48698
48699   jresult = result;
48700   return jresult;
48701 }
48702
48703
48704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFarClippingPlane(void * jarg1, float jarg2) {
48705   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48706   float arg2 ;
48707
48708   arg1 = (Dali::CameraActor *)jarg1;
48709   arg2 = (float)jarg2;
48710   {
48711     try {
48712       (arg1)->SetFarClippingPlane(arg2);
48713     } catch (std::out_of_range& e) {
48714       {
48715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48716       };
48717     } catch (std::exception& e) {
48718       {
48719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48720       };
48721     } catch (Dali::DaliException e) {
48722       {
48723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48724       };
48725     } catch (...) {
48726       {
48727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48728       };
48729     }
48730   }
48731
48732 }
48733
48734
48735 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFarClippingPlane(void * jarg1) {
48736   float jresult ;
48737   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48738   float result;
48739
48740   arg1 = (Dali::CameraActor *)jarg1;
48741   {
48742     try {
48743       result = (float)(arg1)->GetFarClippingPlane();
48744     } catch (std::out_of_range& e) {
48745       {
48746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48747       };
48748     } catch (std::exception& e) {
48749       {
48750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48751       };
48752     } catch (Dali::DaliException e) {
48753       {
48754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48755       };
48756     } catch (...) {
48757       {
48758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48759       };
48760     }
48761   }
48762
48763   jresult = result;
48764   return jresult;
48765 }
48766
48767
48768 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetTargetPosition(void * jarg1, void * jarg2) {
48769   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48770   Dali::Vector3 *arg2 = 0 ;
48771
48772   arg1 = (Dali::CameraActor *)jarg1;
48773   arg2 = (Dali::Vector3 *)jarg2;
48774   if (!arg2) {
48775     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
48776     return ;
48777   }
48778   {
48779     try {
48780       (arg1)->SetTargetPosition((Dali::Vector3 const &)*arg2);
48781     } catch (std::out_of_range& e) {
48782       {
48783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48784       };
48785     } catch (std::exception& e) {
48786       {
48787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48788       };
48789     } catch (Dali::DaliException e) {
48790       {
48791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48792       };
48793     } catch (...) {
48794       {
48795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48796       };
48797     }
48798   }
48799
48800 }
48801
48802
48803 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_GetTargetPosition(void * jarg1) {
48804   void * jresult ;
48805   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48806   Dali::Vector3 result;
48807
48808   arg1 = (Dali::CameraActor *)jarg1;
48809   {
48810     try {
48811       result = ((Dali::CameraActor const *)arg1)->GetTargetPosition();
48812     } catch (std::out_of_range& e) {
48813       {
48814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48815       };
48816     } catch (std::exception& e) {
48817       {
48818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48819       };
48820     } catch (Dali::DaliException e) {
48821       {
48822         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48823       };
48824     } catch (...) {
48825       {
48826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48827       };
48828     }
48829   }
48830
48831   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
48832   return jresult;
48833 }
48834
48835
48836 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetInvertYAxis(void * jarg1, unsigned int jarg2) {
48837   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48838   bool arg2 ;
48839
48840   arg1 = (Dali::CameraActor *)jarg1;
48841   arg2 = jarg2 ? true : false;
48842   {
48843     try {
48844       (arg1)->SetInvertYAxis(arg2);
48845     } catch (std::out_of_range& e) {
48846       {
48847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48848       };
48849     } catch (std::exception& e) {
48850       {
48851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48852       };
48853     } catch (Dali::DaliException e) {
48854       {
48855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48856       };
48857     } catch (...) {
48858       {
48859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48860       };
48861     }
48862   }
48863
48864 }
48865
48866
48867 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CameraActor_GetInvertYAxis(void * jarg1) {
48868   unsigned int jresult ;
48869   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48870   bool result;
48871
48872   arg1 = (Dali::CameraActor *)jarg1;
48873   {
48874     try {
48875       result = (bool)(arg1)->GetInvertYAxis();
48876     } catch (std::out_of_range& e) {
48877       {
48878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48879       };
48880     } catch (std::exception& e) {
48881       {
48882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48883       };
48884     } catch (Dali::DaliException e) {
48885       {
48886         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48887       };
48888     } catch (...) {
48889       {
48890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48891       };
48892     }
48893   }
48894
48895   jresult = result;
48896   return jresult;
48897 }
48898
48899
48900 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetPerspectiveProjection(void * jarg1, void * jarg2) {
48901   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48902   Dali::Size *arg2 = 0 ;
48903
48904   arg1 = (Dali::CameraActor *)jarg1;
48905   arg2 = (Dali::Size *)jarg2;
48906   if (!arg2) {
48907     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
48908     return ;
48909   }
48910   {
48911     try {
48912       (arg1)->SetPerspectiveProjection((Dali::Size const &)*arg2);
48913     } catch (std::out_of_range& e) {
48914       {
48915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48916       };
48917     } catch (std::exception& e) {
48918       {
48919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48920       };
48921     } catch (Dali::DaliException e) {
48922       {
48923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48924       };
48925     } catch (...) {
48926       {
48927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48928       };
48929     }
48930   }
48931
48932 }
48933
48934
48935 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_0(void * jarg1, void * jarg2) {
48936   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48937   Dali::Size *arg2 = 0 ;
48938
48939   arg1 = (Dali::CameraActor *)jarg1;
48940   arg2 = (Dali::Size *)jarg2;
48941   if (!arg2) {
48942     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
48943     return ;
48944   }
48945   {
48946     try {
48947       (arg1)->SetOrthographicProjection((Dali::Size const &)*arg2);
48948     } catch (std::out_of_range& e) {
48949       {
48950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48951       };
48952     } catch (std::exception& e) {
48953       {
48954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48955       };
48956     } catch (Dali::DaliException e) {
48957       {
48958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48959       };
48960     } catch (...) {
48961       {
48962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48963       };
48964     }
48965   }
48966
48967 }
48968
48969
48970 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7) {
48971   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48972   float arg2 ;
48973   float arg3 ;
48974   float arg4 ;
48975   float arg5 ;
48976   float arg6 ;
48977   float arg7 ;
48978
48979   arg1 = (Dali::CameraActor *)jarg1;
48980   arg2 = (float)jarg2;
48981   arg3 = (float)jarg3;
48982   arg4 = (float)jarg4;
48983   arg5 = (float)jarg5;
48984   arg6 = (float)jarg6;
48985   arg7 = (float)jarg7;
48986   {
48987     try {
48988       (arg1)->SetOrthographicProjection(arg2,arg3,arg4,arg5,arg6,arg7);
48989     } catch (std::out_of_range& e) {
48990       {
48991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48992       };
48993     } catch (std::exception& e) {
48994       {
48995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48996       };
48997     } catch (Dali::DaliException e) {
48998       {
48999         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49000       };
49001     } catch (...) {
49002       {
49003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49004       };
49005     }
49006   }
49007
49008 }
49009
49010
49011 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_0() {
49012   void * jresult ;
49013   std::pair< std::string,Dali::Property::Value > *result = 0 ;
49014
49015   {
49016     try {
49017       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >();
49018     } catch (std::out_of_range& e) {
49019       {
49020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49021       };
49022     } catch (std::exception& e) {
49023       {
49024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49025       };
49026     } catch (Dali::DaliException e) {
49027       {
49028         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49029       };
49030     } catch (...) {
49031       {
49032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49033       };
49034     }
49035   }
49036
49037   jresult = (void *)result;
49038   return jresult;
49039 }
49040
49041
49042 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_1(char * jarg1, void * jarg2) {
49043   void * jresult ;
49044   std::string arg1 ;
49045   Dali::Property::Value arg2 ;
49046   Dali::Property::Value *argp2 ;
49047   std::pair< std::string,Dali::Property::Value > *result = 0 ;
49048
49049   if (!jarg1) {
49050     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
49051     return 0;
49052   }
49053   (&arg1)->assign(jarg1);
49054   argp2 = (Dali::Property::Value *)jarg2;
49055   if (!argp2) {
49056     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
49057     return 0;
49058   }
49059   arg2 = *argp2;
49060   {
49061     try {
49062       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >(arg1,arg2);
49063     } catch (std::out_of_range& e) {
49064       {
49065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49066       };
49067     } catch (std::exception& e) {
49068       {
49069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49070       };
49071     } catch (Dali::DaliException e) {
49072       {
49073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49074       };
49075     } catch (...) {
49076       {
49077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49078       };
49079     }
49080   }
49081
49082   jresult = (void *)result;
49083   return jresult;
49084 }
49085
49086
49087 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_2(void * jarg1) {
49088   void * jresult ;
49089   std::pair< std::string,Dali::Property::Value > *arg1 = 0 ;
49090   std::pair< std::string,Dali::Property::Value > *result = 0 ;
49091
49092   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49093   if (!arg1) {
49094     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< std::string,Dali::Property::Value > const & type is null", 0);
49095     return 0;
49096   }
49097   {
49098     try {
49099       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);
49100     } catch (std::out_of_range& e) {
49101       {
49102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49103       };
49104     } catch (std::exception& e) {
49105       {
49106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49107       };
49108     } catch (Dali::DaliException e) {
49109       {
49110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49111       };
49112     } catch (...) {
49113       {
49114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49115       };
49116     }
49117   }
49118
49119   jresult = (void *)result;
49120   return jresult;
49121 }
49122
49123
49124 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_first_set(void * jarg1, char * jarg2) {
49125   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49126   std::string *arg2 = 0 ;
49127
49128   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49129   if (!jarg2) {
49130     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
49131     return ;
49132   }
49133   std::string arg2_str(jarg2);
49134   arg2 = &arg2_str;
49135   if (arg1) (arg1)->first = *arg2;
49136
49137   //argout typemap for const std::string&
49138
49139 }
49140
49141
49142 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_StringValuePair_first_get(void * jarg1) {
49143   char * jresult ;
49144   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49145   std::string *result = 0 ;
49146
49147   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49148   result = (std::string *) & ((arg1)->first);
49149   jresult = SWIG_csharp_string_callback(result->c_str());
49150   return jresult;
49151 }
49152
49153
49154 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_second_set(void * jarg1, void * jarg2) {
49155   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49156   Dali::Property::Value *arg2 = (Dali::Property::Value *) 0 ;
49157
49158   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49159   arg2 = (Dali::Property::Value *)jarg2;
49160   if (arg1) (arg1)->second = *arg2;
49161 }
49162
49163
49164 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StringValuePair_second_get(void * jarg1) {
49165   void * jresult ;
49166   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49167   Dali::Property::Value *result = 0 ;
49168
49169   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49170   result = (Dali::Property::Value *)& ((arg1)->second);
49171   jresult = (void *)result;
49172   return jresult;
49173 }
49174
49175
49176 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StringValuePair(void * jarg1) {
49177   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49178
49179   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49180   {
49181     try {
49182       delete arg1;
49183     } catch (std::out_of_range& e) {
49184       {
49185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49186       };
49187     } catch (std::exception& e) {
49188       {
49189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49190       };
49191     } catch (Dali::DaliException e) {
49192       {
49193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49194       };
49195     } catch (...) {
49196       {
49197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49198       };
49199     }
49200   }
49201
49202 }
49203
49204
49205 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Clear(void * jarg1) {
49206   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49207
49208   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49209   {
49210     try {
49211       (arg1)->clear();
49212     } catch (std::out_of_range& e) {
49213       {
49214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49215       };
49216     } catch (std::exception& e) {
49217       {
49218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49219       };
49220     } catch (Dali::DaliException e) {
49221       {
49222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49223       };
49224     } catch (...) {
49225       {
49226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49227       };
49228     }
49229   }
49230
49231 }
49232
49233
49234 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Add(void * jarg1, void * jarg2) {
49235   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49236   Dali::TouchPoint *arg2 = 0 ;
49237
49238   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49239   arg2 = (Dali::TouchPoint *)jarg2;
49240   if (!arg2) {
49241     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49242     return ;
49243   }
49244   {
49245     try {
49246       (arg1)->push_back((Dali::TouchPoint const &)*arg2);
49247     } catch (std::out_of_range& e) {
49248       {
49249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49250       };
49251     } catch (std::exception& e) {
49252       {
49253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49254       };
49255     } catch (Dali::DaliException e) {
49256       {
49257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49258       };
49259     } catch (...) {
49260       {
49261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49262       };
49263     }
49264   }
49265
49266 }
49267
49268
49269 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_size(void * jarg1) {
49270   unsigned long jresult ;
49271   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49272   std::vector< Dali::TouchPoint >::size_type result;
49273
49274   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49275   {
49276     try {
49277       result = ((std::vector< Dali::TouchPoint > const *)arg1)->size();
49278     } catch (std::out_of_range& e) {
49279       {
49280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49281       };
49282     } catch (std::exception& e) {
49283       {
49284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49285       };
49286     } catch (Dali::DaliException e) {
49287       {
49288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49289       };
49290     } catch (...) {
49291       {
49292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49293       };
49294     }
49295   }
49296
49297   jresult = (unsigned long)result;
49298   return jresult;
49299 }
49300
49301
49302 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_capacity(void * jarg1) {
49303   unsigned long jresult ;
49304   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49305   std::vector< Dali::TouchPoint >::size_type result;
49306
49307   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49308   {
49309     try {
49310       result = ((std::vector< Dali::TouchPoint > const *)arg1)->capacity();
49311     } catch (std::out_of_range& e) {
49312       {
49313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49314       };
49315     } catch (std::exception& e) {
49316       {
49317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49318       };
49319     } catch (Dali::DaliException e) {
49320       {
49321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49322       };
49323     } catch (...) {
49324       {
49325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49326       };
49327     }
49328   }
49329
49330   jresult = (unsigned long)result;
49331   return jresult;
49332 }
49333
49334
49335 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_reserve(void * jarg1, unsigned long jarg2) {
49336   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49337   std::vector< Dali::TouchPoint >::size_type arg2 ;
49338
49339   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49340   arg2 = (std::vector< Dali::TouchPoint >::size_type)jarg2;
49341   {
49342     try {
49343       (arg1)->reserve(arg2);
49344     } catch (std::out_of_range& e) {
49345       {
49346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49347       };
49348     } catch (std::exception& e) {
49349       {
49350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49351       };
49352     } catch (Dali::DaliException e) {
49353       {
49354         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49355       };
49356     } catch (...) {
49357       {
49358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49359       };
49360     }
49361   }
49362
49363 }
49364
49365
49366 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_0() {
49367   void * jresult ;
49368   std::vector< Dali::TouchPoint > *result = 0 ;
49369
49370   {
49371     try {
49372       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >();
49373     } catch (std::out_of_range& e) {
49374       {
49375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49376       };
49377     } catch (std::exception& e) {
49378       {
49379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49380       };
49381     } catch (Dali::DaliException e) {
49382       {
49383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49384       };
49385     } catch (...) {
49386       {
49387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49388       };
49389     }
49390   }
49391
49392   jresult = (void *)result;
49393   return jresult;
49394 }
49395
49396
49397 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_1(void * jarg1) {
49398   void * jresult ;
49399   std::vector< Dali::TouchPoint > *arg1 = 0 ;
49400   std::vector< Dali::TouchPoint > *result = 0 ;
49401
49402   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49403   if (!arg1) {
49404     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49405     return 0;
49406   }
49407   {
49408     try {
49409       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >((std::vector< Dali::TouchPoint > const &)*arg1);
49410     } catch (std::out_of_range& e) {
49411       {
49412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49413       };
49414     } catch (std::exception& e) {
49415       {
49416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49417       };
49418     } catch (Dali::DaliException e) {
49419       {
49420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49421       };
49422     } catch (...) {
49423       {
49424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49425       };
49426     }
49427   }
49428
49429   jresult = (void *)result;
49430   return jresult;
49431 }
49432
49433
49434 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_2(int jarg1) {
49435   void * jresult ;
49436   int arg1 ;
49437   std::vector< Dali::TouchPoint > *result = 0 ;
49438
49439   arg1 = (int)jarg1;
49440   {
49441     try {
49442       try {
49443         result = (std::vector< Dali::TouchPoint > *)new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(arg1);
49444       }
49445       catch(std::out_of_range &_e) {
49446         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49447         return 0;
49448       }
49449
49450     } catch (std::out_of_range& e) {
49451       {
49452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49453       };
49454     } catch (std::exception& e) {
49455       {
49456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49457       };
49458     } catch (Dali::DaliException e) {
49459       {
49460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49461       };
49462     } catch (...) {
49463       {
49464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49465       };
49466     }
49467   }
49468
49469   jresult = (void *)result;
49470   return jresult;
49471 }
49472
49473
49474 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitemcopy(void * jarg1, int jarg2) {
49475   void * jresult ;
49476   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49477   int arg2 ;
49478   SwigValueWrapper< Dali::TouchPoint > result;
49479
49480   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49481   arg2 = (int)jarg2;
49482   {
49483     try {
49484       try {
49485         result = std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(arg1,arg2);
49486       }
49487       catch(std::out_of_range &_e) {
49488         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49489         return 0;
49490       }
49491
49492     } catch (std::out_of_range& e) {
49493       {
49494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49495       };
49496     } catch (std::exception& e) {
49497       {
49498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49499       };
49500     } catch (Dali::DaliException e) {
49501       {
49502         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49503       };
49504     } catch (...) {
49505       {
49506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49507       };
49508     }
49509   }
49510
49511   jresult = new Dali::TouchPoint((const Dali::TouchPoint &)result);
49512   return jresult;
49513 }
49514
49515
49516 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitem(void * jarg1, int jarg2) {
49517   void * jresult ;
49518   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49519   int arg2 ;
49520   Dali::TouchPoint *result = 0 ;
49521
49522   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49523   arg2 = (int)jarg2;
49524   {
49525     try {
49526       try {
49527         result = (Dali::TouchPoint *) &std_vector_Sl_Dali_TouchPoint_Sg__getitem(arg1,arg2);
49528       }
49529       catch(std::out_of_range &_e) {
49530         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49531         return 0;
49532       }
49533
49534     } catch (std::out_of_range& e) {
49535       {
49536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49537       };
49538     } catch (std::exception& e) {
49539       {
49540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49541       };
49542     } catch (Dali::DaliException e) {
49543       {
49544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49545       };
49546     } catch (...) {
49547       {
49548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49549       };
49550     }
49551   }
49552
49553   jresult = (void *)result;
49554   return jresult;
49555 }
49556
49557
49558 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
49559   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49560   int arg2 ;
49561   Dali::TouchPoint *arg3 = 0 ;
49562
49563   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49564   arg2 = (int)jarg2;
49565   arg3 = (Dali::TouchPoint *)jarg3;
49566   if (!arg3) {
49567     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49568     return ;
49569   }
49570   {
49571     try {
49572       try {
49573         std_vector_Sl_Dali_TouchPoint_Sg__setitem(arg1,arg2,(Dali::TouchPoint const &)*arg3);
49574       }
49575       catch(std::out_of_range &_e) {
49576         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49577         return ;
49578       }
49579
49580     } catch (std::out_of_range& e) {
49581       {
49582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49583       };
49584     } catch (std::exception& e) {
49585       {
49586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49587       };
49588     } catch (Dali::DaliException e) {
49589       {
49590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49591       };
49592     } catch (...) {
49593       {
49594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49595       };
49596     }
49597   }
49598
49599 }
49600
49601
49602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_AddRange(void * jarg1, void * jarg2) {
49603   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49604   std::vector< Dali::TouchPoint > *arg2 = 0 ;
49605
49606   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49607   arg2 = (std::vector< Dali::TouchPoint > *)jarg2;
49608   if (!arg2) {
49609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49610     return ;
49611   }
49612   {
49613     try {
49614       std_vector_Sl_Dali_TouchPoint_Sg__AddRange(arg1,(std::vector< Dali::TouchPoint > const &)*arg2);
49615     } catch (std::out_of_range& e) {
49616       {
49617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49618       };
49619     } catch (std::exception& e) {
49620       {
49621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49622       };
49623     } catch (Dali::DaliException e) {
49624       {
49625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49626       };
49627     } catch (...) {
49628       {
49629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49630       };
49631     }
49632   }
49633
49634 }
49635
49636
49637 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
49638   void * jresult ;
49639   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49640   int arg2 ;
49641   int arg3 ;
49642   std::vector< Dali::TouchPoint > *result = 0 ;
49643
49644   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49645   arg2 = (int)jarg2;
49646   arg3 = (int)jarg3;
49647   {
49648     try {
49649       try {
49650         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__GetRange(arg1,arg2,arg3);
49651       }
49652       catch(std::out_of_range &_e) {
49653         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49654         return 0;
49655       }
49656       catch(std::invalid_argument &_e) {
49657         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
49658         return 0;
49659       }
49660
49661     } catch (std::out_of_range& e) {
49662       {
49663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49664       };
49665     } catch (std::exception& e) {
49666       {
49667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49668       };
49669     } catch (Dali::DaliException e) {
49670       {
49671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49672       };
49673     } catch (...) {
49674       {
49675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49676       };
49677     }
49678   }
49679
49680   jresult = (void *)result;
49681   return jresult;
49682 }
49683
49684
49685 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
49686   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49687   int arg2 ;
49688   Dali::TouchPoint *arg3 = 0 ;
49689
49690   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49691   arg2 = (int)jarg2;
49692   arg3 = (Dali::TouchPoint *)jarg3;
49693   if (!arg3) {
49694     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49695     return ;
49696   }
49697   {
49698     try {
49699       try {
49700         std_vector_Sl_Dali_TouchPoint_Sg__Insert(arg1,arg2,(Dali::TouchPoint const &)*arg3);
49701       }
49702       catch(std::out_of_range &_e) {
49703         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49704         return ;
49705       }
49706
49707     } catch (std::out_of_range& e) {
49708       {
49709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49710       };
49711     } catch (std::exception& e) {
49712       {
49713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49714       };
49715     } catch (Dali::DaliException e) {
49716       {
49717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49718       };
49719     } catch (...) {
49720       {
49721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49722       };
49723     }
49724   }
49725
49726 }
49727
49728
49729 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
49730   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49731   int arg2 ;
49732   std::vector< Dali::TouchPoint > *arg3 = 0 ;
49733
49734   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49735   arg2 = (int)jarg2;
49736   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
49737   if (!arg3) {
49738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49739     return ;
49740   }
49741   {
49742     try {
49743       try {
49744         std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
49745       }
49746       catch(std::out_of_range &_e) {
49747         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49748         return ;
49749       }
49750
49751     } catch (std::out_of_range& e) {
49752       {
49753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49754       };
49755     } catch (std::exception& e) {
49756       {
49757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49758       };
49759     } catch (Dali::DaliException e) {
49760       {
49761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49762       };
49763     } catch (...) {
49764       {
49765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49766       };
49767     }
49768   }
49769
49770 }
49771
49772
49773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveAt(void * jarg1, int jarg2) {
49774   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49775   int arg2 ;
49776
49777   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49778   arg2 = (int)jarg2;
49779   {
49780     try {
49781       try {
49782         std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(arg1,arg2);
49783       }
49784       catch(std::out_of_range &_e) {
49785         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49786         return ;
49787       }
49788
49789     } catch (std::out_of_range& e) {
49790       {
49791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49792       };
49793     } catch (std::exception& e) {
49794       {
49795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49796       };
49797     } catch (Dali::DaliException e) {
49798       {
49799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49800       };
49801     } catch (...) {
49802       {
49803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49804       };
49805     }
49806   }
49807
49808 }
49809
49810
49811 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
49812   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49813   int arg2 ;
49814   int arg3 ;
49815
49816   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49817   arg2 = (int)jarg2;
49818   arg3 = (int)jarg3;
49819   {
49820     try {
49821       try {
49822         std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(arg1,arg2,arg3);
49823       }
49824       catch(std::out_of_range &_e) {
49825         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49826         return ;
49827       }
49828       catch(std::invalid_argument &_e) {
49829         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
49830         return ;
49831       }
49832
49833     } catch (std::out_of_range& e) {
49834       {
49835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49836       };
49837     } catch (std::exception& e) {
49838       {
49839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49840       };
49841     } catch (Dali::DaliException e) {
49842       {
49843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49844       };
49845     } catch (...) {
49846       {
49847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49848       };
49849     }
49850   }
49851
49852 }
49853
49854
49855 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_Repeat(void * jarg1, int jarg2) {
49856   void * jresult ;
49857   Dali::TouchPoint *arg1 = 0 ;
49858   int arg2 ;
49859   std::vector< Dali::TouchPoint > *result = 0 ;
49860
49861   arg1 = (Dali::TouchPoint *)jarg1;
49862   if (!arg1) {
49863     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49864     return 0;
49865   }
49866   arg2 = (int)jarg2;
49867   {
49868     try {
49869       try {
49870         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__Repeat((Dali::TouchPoint const &)*arg1,arg2);
49871       }
49872       catch(std::out_of_range &_e) {
49873         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49874         return 0;
49875       }
49876
49877     } catch (std::out_of_range& e) {
49878       {
49879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49880       };
49881     } catch (std::exception& e) {
49882       {
49883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49884       };
49885     } catch (Dali::DaliException e) {
49886       {
49887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49888       };
49889     } catch (...) {
49890       {
49891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49892       };
49893     }
49894   }
49895
49896   jresult = (void *)result;
49897   return jresult;
49898 }
49899
49900
49901 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_0(void * jarg1) {
49902   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49903
49904   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49905   {
49906     try {
49907       std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(arg1);
49908     } catch (std::out_of_range& e) {
49909       {
49910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49911       };
49912     } catch (std::exception& e) {
49913       {
49914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49915       };
49916     } catch (Dali::DaliException e) {
49917       {
49918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49919       };
49920     } catch (...) {
49921       {
49922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49923       };
49924     }
49925   }
49926
49927 }
49928
49929
49930 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
49931   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49932   int arg2 ;
49933   int arg3 ;
49934
49935   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49936   arg2 = (int)jarg2;
49937   arg3 = (int)jarg3;
49938   {
49939     try {
49940       try {
49941         std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
49942       }
49943       catch(std::out_of_range &_e) {
49944         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49945         return ;
49946       }
49947       catch(std::invalid_argument &_e) {
49948         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
49949         return ;
49950       }
49951
49952     } catch (std::out_of_range& e) {
49953       {
49954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49955       };
49956     } catch (std::exception& e) {
49957       {
49958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49959       };
49960     } catch (Dali::DaliException e) {
49961       {
49962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49963       };
49964     } catch (...) {
49965       {
49966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49967       };
49968     }
49969   }
49970
49971 }
49972
49973
49974 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
49975   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49976   int arg2 ;
49977   std::vector< Dali::TouchPoint > *arg3 = 0 ;
49978
49979   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49980   arg2 = (int)jarg2;
49981   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
49982   if (!arg3) {
49983     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49984     return ;
49985   }
49986   {
49987     try {
49988       try {
49989         std_vector_Sl_Dali_TouchPoint_Sg__SetRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
49990       }
49991       catch(std::out_of_range &_e) {
49992         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49993         return ;
49994       }
49995
49996     } catch (std::out_of_range& e) {
49997       {
49998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49999       };
50000     } catch (std::exception& e) {
50001       {
50002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50003       };
50004     } catch (Dali::DaliException e) {
50005       {
50006         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50007       };
50008     } catch (...) {
50009       {
50010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50011       };
50012     }
50013   }
50014
50015 }
50016
50017
50018 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPointContainer(void * jarg1) {
50019   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
50020
50021   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
50022   {
50023     try {
50024       delete arg1;
50025     } catch (std::out_of_range& e) {
50026       {
50027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50028       };
50029     } catch (std::exception& e) {
50030       {
50031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50032       };
50033     } catch (Dali::DaliException e) {
50034       {
50035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50036       };
50037     } catch (...) {
50038       {
50039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50040       };
50041     }
50042   }
50043
50044 }
50045
50046
50047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_0() {
50048   void * jresult ;
50049   Dali::Rect< int > *result = 0 ;
50050
50051   {
50052     try {
50053       result = (Dali::Rect< int > *)new Dali::Rect< int >();
50054     } catch (std::out_of_range& e) {
50055       {
50056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50057       };
50058     } catch (std::exception& e) {
50059       {
50060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50061       };
50062     } catch (Dali::DaliException e) {
50063       {
50064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50065       };
50066     } catch (...) {
50067       {
50068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50069       };
50070     }
50071   }
50072
50073   jresult = (void *)result;
50074   return jresult;
50075 }
50076
50077
50078 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_1(int jarg1, int jarg2, int jarg3, int jarg4) {
50079   void * jresult ;
50080   int arg1 ;
50081   int arg2 ;
50082   int arg3 ;
50083   int arg4 ;
50084   Dali::Rect< int > *result = 0 ;
50085
50086   arg1 = (int)jarg1;
50087   arg2 = (int)jarg2;
50088   arg3 = (int)jarg3;
50089   arg4 = (int)jarg4;
50090   {
50091     try {
50092       result = (Dali::Rect< int > *)new Dali::Rect< int >(arg1,arg2,arg3,arg4);
50093     } catch (std::out_of_range& e) {
50094       {
50095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50096       };
50097     } catch (std::exception& e) {
50098       {
50099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50100       };
50101     } catch (Dali::DaliException e) {
50102       {
50103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50104       };
50105     } catch (...) {
50106       {
50107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50108       };
50109     }
50110   }
50111
50112   jresult = (void *)result;
50113   return jresult;
50114 }
50115
50116
50117 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_2(void * jarg1) {
50118   void * jresult ;
50119   Dali::Rect< int > *arg1 = 0 ;
50120   Dali::Rect< int > *result = 0 ;
50121
50122   arg1 = (Dali::Rect< int > *)jarg1;
50123   if (!arg1) {
50124     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
50125     return 0;
50126   }
50127   {
50128     try {
50129       result = (Dali::Rect< int > *)new Dali::Rect< int >((Dali::Rect< int > const &)*arg1);
50130     } catch (std::out_of_range& e) {
50131       {
50132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50133       };
50134     } catch (std::exception& e) {
50135       {
50136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50137       };
50138     } catch (Dali::DaliException e) {
50139       {
50140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50141       };
50142     } catch (...) {
50143       {
50144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50145       };
50146     }
50147   }
50148
50149   jresult = (void *)result;
50150   return jresult;
50151 }
50152
50153
50154 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rectangle_Assign(void * jarg1, void * jarg2) {
50155   void * jresult ;
50156   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50157   Dali::Rect< int > *arg2 = 0 ;
50158   Dali::Rect< int > *result = 0 ;
50159
50160   arg1 = (Dali::Rect< int > *)jarg1;
50161   arg2 = (Dali::Rect< int > *)jarg2;
50162   if (!arg2) {
50163     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
50164     return 0;
50165   }
50166   {
50167     try {
50168       result = (Dali::Rect< int > *) &(arg1)->operator =((Dali::Rect< int > const &)*arg2);
50169     } catch (std::out_of_range& e) {
50170       {
50171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50172       };
50173     } catch (std::exception& e) {
50174       {
50175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50176       };
50177     } catch (Dali::DaliException e) {
50178       {
50179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50180       };
50181     } catch (...) {
50182       {
50183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50184       };
50185     }
50186   }
50187
50188   jresult = (void *)result;
50189   return jresult;
50190 }
50191
50192
50193 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_Set(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
50194   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50195   int arg2 ;
50196   int arg3 ;
50197   int arg4 ;
50198   int arg5 ;
50199
50200   arg1 = (Dali::Rect< int > *)jarg1;
50201   arg2 = (int)jarg2;
50202   arg3 = (int)jarg3;
50203   arg4 = (int)jarg4;
50204   arg5 = (int)jarg5;
50205   {
50206     try {
50207       (arg1)->Set(arg2,arg3,arg4,arg5);
50208     } catch (std::out_of_range& e) {
50209       {
50210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50211       };
50212     } catch (std::exception& e) {
50213       {
50214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50215       };
50216     } catch (Dali::DaliException e) {
50217       {
50218         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50219       };
50220     } catch (...) {
50221       {
50222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50223       };
50224     }
50225   }
50226
50227 }
50228
50229
50230 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_IsEmpty(void * jarg1) {
50231   unsigned int jresult ;
50232   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50233   bool result;
50234
50235   arg1 = (Dali::Rect< int > *)jarg1;
50236   {
50237     try {
50238       result = (bool)((Dali::Rect< int > const *)arg1)->IsEmpty();
50239     } catch (std::out_of_range& e) {
50240       {
50241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50242       };
50243     } catch (std::exception& e) {
50244       {
50245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50246       };
50247     } catch (Dali::DaliException e) {
50248       {
50249         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50250       };
50251     } catch (...) {
50252       {
50253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50254       };
50255     }
50256   }
50257
50258   jresult = result;
50259   return jresult;
50260 }
50261
50262
50263 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Left(void * jarg1) {
50264   int jresult ;
50265   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50266   int result;
50267
50268   arg1 = (Dali::Rect< int > *)jarg1;
50269   {
50270     try {
50271       result = (int)((Dali::Rect< int > const *)arg1)->Left();
50272     } catch (std::out_of_range& e) {
50273       {
50274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50275       };
50276     } catch (std::exception& e) {
50277       {
50278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50279       };
50280     } catch (Dali::DaliException e) {
50281       {
50282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50283       };
50284     } catch (...) {
50285       {
50286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50287       };
50288     }
50289   }
50290
50291   jresult = result;
50292   return jresult;
50293 }
50294
50295
50296 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Right(void * jarg1) {
50297   int jresult ;
50298   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50299   int result;
50300
50301   arg1 = (Dali::Rect< int > *)jarg1;
50302   {
50303     try {
50304       result = (int)((Dali::Rect< int > const *)arg1)->Right();
50305     } catch (std::out_of_range& e) {
50306       {
50307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50308       };
50309     } catch (std::exception& e) {
50310       {
50311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50312       };
50313     } catch (Dali::DaliException e) {
50314       {
50315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50316       };
50317     } catch (...) {
50318       {
50319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50320       };
50321     }
50322   }
50323
50324   jresult = result;
50325   return jresult;
50326 }
50327
50328
50329 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Top(void * jarg1) {
50330   int jresult ;
50331   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50332   int result;
50333
50334   arg1 = (Dali::Rect< int > *)jarg1;
50335   {
50336     try {
50337       result = (int)((Dali::Rect< int > const *)arg1)->Top();
50338     } catch (std::out_of_range& e) {
50339       {
50340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50341       };
50342     } catch (std::exception& e) {
50343       {
50344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50345       };
50346     } catch (Dali::DaliException e) {
50347       {
50348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50349       };
50350     } catch (...) {
50351       {
50352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50353       };
50354     }
50355   }
50356
50357   jresult = result;
50358   return jresult;
50359 }
50360
50361
50362 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Bottom(void * jarg1) {
50363   int jresult ;
50364   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50365   int result;
50366
50367   arg1 = (Dali::Rect< int > *)jarg1;
50368   {
50369     try {
50370       result = (int)((Dali::Rect< int > const *)arg1)->Bottom();
50371     } catch (std::out_of_range& e) {
50372       {
50373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50374       };
50375     } catch (std::exception& e) {
50376       {
50377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50378       };
50379     } catch (Dali::DaliException e) {
50380       {
50381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50382       };
50383     } catch (...) {
50384       {
50385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50386       };
50387     }
50388   }
50389
50390   jresult = result;
50391   return jresult;
50392 }
50393
50394
50395 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Area(void * jarg1) {
50396   int jresult ;
50397   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50398   int result;
50399
50400   arg1 = (Dali::Rect< int > *)jarg1;
50401   {
50402     try {
50403       result = (int)((Dali::Rect< int > const *)arg1)->Area();
50404     } catch (std::out_of_range& e) {
50405       {
50406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50407       };
50408     } catch (std::exception& e) {
50409       {
50410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50411       };
50412     } catch (Dali::DaliException e) {
50413       {
50414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50415       };
50416     } catch (...) {
50417       {
50418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50419       };
50420     }
50421   }
50422
50423   jresult = result;
50424   return jresult;
50425 }
50426
50427
50428 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Intersects(void * jarg1, void * jarg2) {
50429   unsigned int jresult ;
50430   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50431   Dali::Rect< int > *arg2 = 0 ;
50432   bool result;
50433
50434   arg1 = (Dali::Rect< int > *)jarg1;
50435   arg2 = (Dali::Rect< int > *)jarg2;
50436   if (!arg2) {
50437     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
50438     return 0;
50439   }
50440   {
50441     try {
50442       result = (bool)((Dali::Rect< int > const *)arg1)->Intersects((Dali::Rect< int > const &)*arg2);
50443     } catch (std::out_of_range& e) {
50444       {
50445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50446       };
50447     } catch (std::exception& e) {
50448       {
50449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50450       };
50451     } catch (Dali::DaliException e) {
50452       {
50453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50454       };
50455     } catch (...) {
50456       {
50457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50458       };
50459     }
50460   }
50461
50462   jresult = result;
50463   return jresult;
50464 }
50465
50466
50467 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Contains(void * jarg1, void * jarg2) {
50468   unsigned int jresult ;
50469   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50470   Dali::Rect< int > *arg2 = 0 ;
50471   bool result;
50472
50473   arg1 = (Dali::Rect< int > *)jarg1;
50474   arg2 = (Dali::Rect< int > *)jarg2;
50475   if (!arg2) {
50476     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
50477     return 0;
50478   }
50479   {
50480     try {
50481       result = (bool)((Dali::Rect< int > const *)arg1)->Contains((Dali::Rect< int > const &)*arg2);
50482     } catch (std::out_of_range& e) {
50483       {
50484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50485       };
50486     } catch (std::exception& e) {
50487       {
50488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50489       };
50490     } catch (Dali::DaliException e) {
50491       {
50492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50493       };
50494     } catch (...) {
50495       {
50496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50497       };
50498     }
50499   }
50500
50501   jresult = result;
50502   return jresult;
50503 }
50504
50505
50506 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_x_set(void * jarg1, int jarg2) {
50507   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50508   int arg2 ;
50509
50510   arg1 = (Dali::Rect< int > *)jarg1;
50511   arg2 = (int)jarg2;
50512   if (arg1) (arg1)->x = arg2;
50513 }
50514
50515
50516 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_x_get(void * jarg1) {
50517   int jresult ;
50518   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50519   int result;
50520
50521   arg1 = (Dali::Rect< int > *)jarg1;
50522   result = (int) ((arg1)->x);
50523   jresult = result;
50524   return jresult;
50525 }
50526
50527
50528 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_left_set(void * jarg1, int jarg2) {
50529   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50530   int arg2 ;
50531
50532   arg1 = (Dali::Rect< int > *)jarg1;
50533   arg2 = (int)jarg2;
50534   if (arg1) (arg1)->left = arg2;
50535 }
50536
50537
50538 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_left_get(void * jarg1) {
50539   int jresult ;
50540   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50541   int result;
50542
50543   arg1 = (Dali::Rect< int > *)jarg1;
50544   result = (int) ((arg1)->left);
50545   jresult = result;
50546   return jresult;
50547 }
50548
50549
50550 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_y_set(void * jarg1, int jarg2) {
50551   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50552   int arg2 ;
50553
50554   arg1 = (Dali::Rect< int > *)jarg1;
50555   arg2 = (int)jarg2;
50556   if (arg1) (arg1)->y = arg2;
50557 }
50558
50559
50560 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_y_get(void * jarg1) {
50561   int jresult ;
50562   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50563   int result;
50564
50565   arg1 = (Dali::Rect< int > *)jarg1;
50566   result = (int) ((arg1)->y);
50567   jresult = result;
50568   return jresult;
50569 }
50570
50571
50572 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_right_set(void * jarg1, int jarg2) {
50573   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50574   int arg2 ;
50575
50576   arg1 = (Dali::Rect< int > *)jarg1;
50577   arg2 = (int)jarg2;
50578   if (arg1) (arg1)->right = arg2;
50579 }
50580
50581
50582 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_right_get(void * jarg1) {
50583   int jresult ;
50584   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50585   int result;
50586
50587   arg1 = (Dali::Rect< int > *)jarg1;
50588   result = (int) ((arg1)->right);
50589   jresult = result;
50590   return jresult;
50591 }
50592
50593
50594 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_width_set(void * jarg1, int jarg2) {
50595   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50596   int arg2 ;
50597
50598   arg1 = (Dali::Rect< int > *)jarg1;
50599   arg2 = (int)jarg2;
50600   if (arg1) (arg1)->width = arg2;
50601 }
50602
50603
50604 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_width_get(void * jarg1) {
50605   int jresult ;
50606   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50607   int result;
50608
50609   arg1 = (Dali::Rect< int > *)jarg1;
50610   result = (int) ((arg1)->width);
50611   jresult = result;
50612   return jresult;
50613 }
50614
50615
50616 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_bottom_set(void * jarg1, int jarg2) {
50617   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50618   int arg2 ;
50619
50620   arg1 = (Dali::Rect< int > *)jarg1;
50621   arg2 = (int)jarg2;
50622   if (arg1) (arg1)->bottom = arg2;
50623 }
50624
50625
50626 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_bottom_get(void * jarg1) {
50627   int jresult ;
50628   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50629   int result;
50630
50631   arg1 = (Dali::Rect< int > *)jarg1;
50632   result = (int) ((arg1)->bottom);
50633   jresult = result;
50634   return jresult;
50635 }
50636
50637
50638 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_height_set(void * jarg1, int jarg2) {
50639   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50640   int arg2 ;
50641
50642   arg1 = (Dali::Rect< int > *)jarg1;
50643   arg2 = (int)jarg2;
50644   if (arg1) (arg1)->height = arg2;
50645 }
50646
50647
50648 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_height_get(void * jarg1) {
50649   int jresult ;
50650   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50651   int result;
50652
50653   arg1 = (Dali::Rect< int > *)jarg1;
50654   result = (int) ((arg1)->height);
50655   jresult = result;
50656   return jresult;
50657 }
50658
50659
50660 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_top_set(void * jarg1, int jarg2) {
50661   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50662   int arg2 ;
50663
50664   arg1 = (Dali::Rect< int > *)jarg1;
50665   arg2 = (int)jarg2;
50666   if (arg1) (arg1)->top = arg2;
50667 }
50668
50669
50670 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_top_get(void * jarg1) {
50671   int jresult ;
50672   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50673   int result;
50674
50675   arg1 = (Dali::Rect< int > *)jarg1;
50676   result = (int) ((arg1)->top);
50677   jresult = result;
50678   return jresult;
50679 }
50680
50681
50682 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rectangle(void * jarg1) {
50683   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50684
50685   arg1 = (Dali::Rect< int > *)jarg1;
50686   {
50687     try {
50688       delete arg1;
50689     } catch (std::out_of_range& e) {
50690       {
50691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50692       };
50693     } catch (std::exception& e) {
50694       {
50695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50696       };
50697     } catch (Dali::DaliException e) {
50698       {
50699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50700       };
50701     } catch (...) {
50702       {
50703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50704       };
50705     }
50706   }
50707
50708 }
50709
50710
50711 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_0() {
50712   void * jresult ;
50713   Dali::Rect< float > *result = 0 ;
50714
50715   {
50716     try {
50717       result = (Dali::Rect< float > *)new Dali::Rect< float >();
50718     } catch (std::out_of_range& e) {
50719       {
50720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50721       };
50722     } catch (std::exception& e) {
50723       {
50724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50725       };
50726     } catch (Dali::DaliException e) {
50727       {
50728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50729       };
50730     } catch (...) {
50731       {
50732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50733       };
50734     }
50735   }
50736
50737   jresult = (void *)result;
50738   return jresult;
50739 }
50740
50741
50742 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
50743   void * jresult ;
50744   float arg1 ;
50745   float arg2 ;
50746   float arg3 ;
50747   float arg4 ;
50748   Dali::Rect< float > *result = 0 ;
50749
50750   arg1 = (float)jarg1;
50751   arg2 = (float)jarg2;
50752   arg3 = (float)jarg4;
50753   arg4 = (float)jarg3;
50754   {
50755     try {
50756       result = (Dali::Rect< float > *)new Dali::Rect< float >(arg1,arg2,arg3,arg4);
50757     } catch (std::out_of_range& e) {
50758       {
50759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50760       };
50761     } catch (std::exception& e) {
50762       {
50763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50764       };
50765     } catch (Dali::DaliException e) {
50766       {
50767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50768       };
50769     } catch (...) {
50770       {
50771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50772       };
50773     }
50774   }
50775
50776   jresult = (void *)result;
50777   return jresult;
50778 }
50779
50780
50781 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_2(void * jarg1) {
50782   void * jresult ;
50783   Dali::Rect< float > *arg1 = 0 ;
50784   Dali::Rect< float > *result = 0 ;
50785
50786   arg1 = (Dali::Rect< float > *)jarg1;
50787   if (!arg1) {
50788     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
50789     return 0;
50790   }
50791   {
50792     try {
50793       result = (Dali::Rect< float > *)new Dali::Rect< float >((Dali::Rect< float > const &)*arg1);
50794     } catch (std::out_of_range& e) {
50795       {
50796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50797       };
50798     } catch (std::exception& e) {
50799       {
50800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50801       };
50802     } catch (Dali::DaliException e) {
50803       {
50804         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50805       };
50806     } catch (...) {
50807       {
50808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50809       };
50810     }
50811   }
50812
50813   jresult = (void *)result;
50814   return jresult;
50815 }
50816
50817
50818 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PaddingType_Assign(void * jarg1, void * jarg2) {
50819   void * jresult ;
50820   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50821   Dali::Rect< float > *arg2 = 0 ;
50822   Dali::Rect< float > *result = 0 ;
50823
50824   arg1 = (Dali::Rect< float > *)jarg1;
50825   arg2 = (Dali::Rect< float > *)jarg2;
50826   if (!arg2) {
50827     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
50828     return 0;
50829   }
50830   {
50831     try {
50832       result = (Dali::Rect< float > *) &(arg1)->operator =((Dali::Rect< float > const &)*arg2);
50833     } catch (std::out_of_range& e) {
50834       {
50835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50836       };
50837     } catch (std::exception& e) {
50838       {
50839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50840       };
50841     } catch (Dali::DaliException e) {
50842       {
50843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50844       };
50845     } catch (...) {
50846       {
50847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50848       };
50849     }
50850   }
50851
50852   jresult = (void *)result;
50853   return jresult;
50854 }
50855
50856
50857 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_Set(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
50858   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50859   float arg2 ;
50860   float arg3 ;
50861   float arg4 ;
50862   float arg5 ;
50863
50864   arg1 = (Dali::Rect< float > *)jarg1;
50865   arg2 = (float)jarg2;
50866   arg3 = (float)jarg3;
50867   arg4 = (float)jarg5;
50868   arg5 = (float)jarg4;
50869   {
50870     try {
50871       (arg1)->Set(arg2,arg3,arg4,arg5);
50872     } catch (std::out_of_range& e) {
50873       {
50874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50875       };
50876     } catch (std::exception& e) {
50877       {
50878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50879       };
50880     } catch (Dali::DaliException e) {
50881       {
50882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50883       };
50884     } catch (...) {
50885       {
50886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50887       };
50888     }
50889   }
50890
50891 }
50892
50893
50894 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_left_set(void * jarg1, float jarg2) {
50895   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50896   float arg2 ;
50897
50898   arg1 = (Dali::Rect< float > *)jarg1;
50899   arg2 = (float)jarg2;
50900   if (arg1) (arg1)->left = arg2;
50901 }
50902
50903
50904 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_left_get(void * jarg1) {
50905   float jresult ;
50906   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50907   float result;
50908
50909   arg1 = (Dali::Rect< float > *)jarg1;
50910   result = (float) ((arg1)->left);
50911   jresult = result;
50912   return jresult;
50913 }
50914
50915
50916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_start_set(void * jarg1, float jarg2) {
50917   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50918   float arg2 ;
50919
50920   arg1 = (Dali::Rect< float > *)jarg1;
50921   arg2 = (float)jarg2;
50922   if (arg1) (arg1)->left = arg2;
50923 }
50924
50925
50926 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_start_get(void * jarg1) {
50927   float jresult ;
50928   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50929   float result;
50930
50931   arg1 = (Dali::Rect< float > *)jarg1;
50932   result = (float) ((arg1)->left);
50933   jresult = result;
50934   return jresult;
50935 }
50936
50937
50938 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_right_set(void * jarg1, float jarg2) {
50939   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50940   float arg2 ;
50941
50942   arg1 = (Dali::Rect< float > *)jarg1;
50943   arg2 = (float)jarg2;
50944   if (arg1) (arg1)->right = arg2;
50945 }
50946
50947
50948 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_right_get(void * jarg1) {
50949   float jresult ;
50950   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50951   float result;
50952
50953   arg1 = (Dali::Rect< float > *)jarg1;
50954   result = (float) ((arg1)->right);
50955   jresult = result;
50956   return jresult;
50957 }
50958
50959
50960 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_end_set(void * jarg1, float jarg2) {
50961   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50962   float arg2 ;
50963
50964   arg1 = (Dali::Rect< float > *)jarg1;
50965   arg2 = (float)jarg2;
50966   if (arg1) (arg1)->right = arg2;
50967 }
50968
50969
50970 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_end_get(void * jarg1) {
50971   float jresult ;
50972   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50973   float result;
50974
50975   arg1 = (Dali::Rect< float > *)jarg1;
50976   result = (float) ((arg1)->right);
50977   jresult = result;
50978   return jresult;
50979 }
50980
50981
50982 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_bottom_set(void * jarg1, float jarg2) {
50983   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50984   float arg2 ;
50985
50986   arg1 = (Dali::Rect< float > *)jarg1;
50987   arg2 = (float)jarg2;
50988   if (arg1) (arg1)->bottom = arg2;
50989 }
50990
50991
50992 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_bottom_get(void * jarg1) {
50993   float jresult ;
50994   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50995   float result;
50996
50997   arg1 = (Dali::Rect< float > *)jarg1;
50998   result = (float) ((arg1)->bottom);
50999   jresult = result;
51000   return jresult;
51001 }
51002
51003
51004 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_top_set(void * jarg1, float jarg2) {
51005   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51006   float arg2 ;
51007
51008   arg1 = (Dali::Rect< float > *)jarg1;
51009   arg2 = (float)jarg2;
51010   if (arg1) (arg1)->top = arg2;
51011 }
51012
51013
51014 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_top_get(void * jarg1) {
51015   float jresult ;
51016   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51017   float result;
51018
51019   arg1 = (Dali::Rect< float > *)jarg1;
51020   result = (float) ((arg1)->top);
51021   jresult = result;
51022   return jresult;
51023 }
51024
51025
51026 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PaddingType(void * jarg1) {
51027   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51028
51029   arg1 = (Dali::Rect< float > *)jarg1;
51030   {
51031     try {
51032       delete arg1;
51033     } catch (std::out_of_range& e) {
51034       {
51035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51036       };
51037     } catch (std::exception& e) {
51038       {
51039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51040       };
51041     } catch (Dali::DaliException e) {
51042       {
51043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51044       };
51045     } catch (...) {
51046       {
51047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51048       };
51049     }
51050   }
51051
51052 }
51053
51054
51055 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorInteger_BaseType_get() {
51056   int jresult ;
51057   int result;
51058
51059   result = (int)Dali::Vector< int >::BaseType;
51060   jresult = (int)result;
51061   return jresult;
51062 }
51063
51064
51065 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_0() {
51066   void * jresult ;
51067   Dali::Vector< int > *result = 0 ;
51068
51069   {
51070     try {
51071       result = (Dali::Vector< int > *)new Dali::Vector< int >();
51072     } catch (std::out_of_range& e) {
51073       {
51074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51075       };
51076     } catch (std::exception& e) {
51077       {
51078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51079       };
51080     } catch (Dali::DaliException e) {
51081       {
51082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51083       };
51084     } catch (...) {
51085       {
51086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51087       };
51088     }
51089   }
51090
51091   jresult = (void *)result;
51092   return jresult;
51093 }
51094
51095
51096 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorInteger(void * jarg1) {
51097   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51098
51099   arg1 = (Dali::Vector< int > *)jarg1;
51100   {
51101     try {
51102       delete arg1;
51103     } catch (std::out_of_range& e) {
51104       {
51105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51106       };
51107     } catch (std::exception& e) {
51108       {
51109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51110       };
51111     } catch (Dali::DaliException e) {
51112       {
51113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51114       };
51115     } catch (...) {
51116       {
51117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51118       };
51119     }
51120   }
51121
51122 }
51123
51124
51125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_1(void * jarg1) {
51126   void * jresult ;
51127   Dali::Vector< int > *arg1 = 0 ;
51128   Dali::Vector< int > *result = 0 ;
51129
51130   arg1 = (Dali::Vector< int > *)jarg1;
51131   if (!arg1) {
51132     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
51133     return 0;
51134   }
51135   {
51136     try {
51137       result = (Dali::Vector< int > *)new Dali::Vector< int >((Dali::Vector< int > const &)*arg1);
51138     } catch (std::out_of_range& e) {
51139       {
51140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51141       };
51142     } catch (std::exception& e) {
51143       {
51144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51145       };
51146     } catch (Dali::DaliException e) {
51147       {
51148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51149       };
51150     } catch (...) {
51151       {
51152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51153       };
51154     }
51155   }
51156
51157   jresult = (void *)result;
51158   return jresult;
51159 }
51160
51161
51162 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Assign(void * jarg1, void * jarg2) {
51163   void * jresult ;
51164   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51165   Dali::Vector< int > *arg2 = 0 ;
51166   Dali::Vector< int > *result = 0 ;
51167
51168   arg1 = (Dali::Vector< int > *)jarg1;
51169   arg2 = (Dali::Vector< int > *)jarg2;
51170   if (!arg2) {
51171     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
51172     return 0;
51173   }
51174   {
51175     try {
51176       result = (Dali::Vector< int > *) &(arg1)->operator =((Dali::Vector< int > const &)*arg2);
51177     } catch (std::out_of_range& e) {
51178       {
51179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51180       };
51181     } catch (std::exception& e) {
51182       {
51183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51184       };
51185     } catch (Dali::DaliException e) {
51186       {
51187         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51188       };
51189     } catch (...) {
51190       {
51191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51192       };
51193     }
51194   }
51195
51196   jresult = (void *)result;
51197   return jresult;
51198 }
51199
51200
51201 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Begin(void * jarg1) {
51202   void * jresult ;
51203   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51204   Dali::Vector< int >::Iterator result;
51205
51206   arg1 = (Dali::Vector< int > *)jarg1;
51207   {
51208     try {
51209       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->Begin();
51210     } catch (std::out_of_range& e) {
51211       {
51212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51213       };
51214     } catch (std::exception& e) {
51215       {
51216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51217       };
51218     } catch (Dali::DaliException e) {
51219       {
51220         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51221       };
51222     } catch (...) {
51223       {
51224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51225       };
51226     }
51227   }
51228
51229   jresult = (void *)result;
51230   return jresult;
51231 }
51232
51233
51234 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_End(void * jarg1) {
51235   void * jresult ;
51236   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51237   Dali::Vector< int >::Iterator result;
51238
51239   arg1 = (Dali::Vector< int > *)jarg1;
51240   {
51241     try {
51242       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->End();
51243     } catch (std::out_of_range& e) {
51244       {
51245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51246       };
51247     } catch (std::exception& e) {
51248       {
51249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51250       };
51251     } catch (Dali::DaliException e) {
51252       {
51253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51254       };
51255     } catch (...) {
51256       {
51257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51258       };
51259     }
51260   }
51261
51262   jresult = (void *)result;
51263   return jresult;
51264 }
51265
51266
51267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
51268   void * jresult ;
51269   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51270   Dali::Vector< int >::SizeType arg2 ;
51271   Dali::Vector< int >::ItemType *result = 0 ;
51272
51273   arg1 = (Dali::Vector< int > *)jarg1;
51274   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51275   {
51276     try {
51277       result = (Dali::Vector< int >::ItemType *) &(arg1)->operator [](arg2);
51278     } catch (std::out_of_range& e) {
51279       {
51280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51281       };
51282     } catch (std::exception& e) {
51283       {
51284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51285       };
51286     } catch (Dali::DaliException e) {
51287       {
51288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51289       };
51290     } catch (...) {
51291       {
51292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51293       };
51294     }
51295   }
51296
51297   jresult = (void *)result;
51298   return jresult;
51299 }
51300
51301
51302 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_PushBack(void * jarg1, int jarg2) {
51303   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51304   Dali::Vector< int >::ItemType *arg2 = 0 ;
51305   Dali::Vector< int >::ItemType temp2 ;
51306
51307   arg1 = (Dali::Vector< int > *)jarg1;
51308   temp2 = (Dali::Vector< int >::ItemType)jarg2;
51309   arg2 = &temp2;
51310   {
51311     try {
51312       (arg1)->PushBack((Dali::Vector< int >::ItemType const &)*arg2);
51313     } catch (std::out_of_range& e) {
51314       {
51315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51316       };
51317     } catch (std::exception& e) {
51318       {
51319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51320       };
51321     } catch (Dali::DaliException e) {
51322       {
51323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51324       };
51325     } catch (...) {
51326       {
51327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51328       };
51329     }
51330   }
51331
51332 }
51333
51334
51335 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_0(void * jarg1, void * jarg2, int jarg3) {
51336   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51337   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51338   Dali::Vector< int >::ItemType *arg3 = 0 ;
51339   Dali::Vector< int >::ItemType temp3 ;
51340
51341   arg1 = (Dali::Vector< int > *)jarg1;
51342   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51343   temp3 = (Dali::Vector< int >::ItemType)jarg3;
51344   arg3 = &temp3;
51345   {
51346     try {
51347       (arg1)->Insert(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
51348     } catch (std::out_of_range& e) {
51349       {
51350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51351       };
51352     } catch (std::exception& e) {
51353       {
51354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51355       };
51356     } catch (Dali::DaliException e) {
51357       {
51358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51359       };
51360     } catch (...) {
51361       {
51362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51363       };
51364     }
51365   }
51366
51367 }
51368
51369
51370 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
51371   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51372   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51373   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
51374   Dali::Vector< int >::Iterator arg4 = (Dali::Vector< int >::Iterator) 0 ;
51375
51376   arg1 = (Dali::Vector< int > *)jarg1;
51377   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51378   arg3 = (Dali::Vector< int >::Iterator)jarg3;
51379   arg4 = (Dali::Vector< int >::Iterator)jarg4;
51380   {
51381     try {
51382       (arg1)->Insert(arg2,arg3,arg4);
51383     } catch (std::out_of_range& e) {
51384       {
51385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51386       };
51387     } catch (std::exception& e) {
51388       {
51389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51390       };
51391     } catch (Dali::DaliException e) {
51392       {
51393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51394       };
51395     } catch (...) {
51396       {
51397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51398       };
51399     }
51400   }
51401
51402 }
51403
51404
51405 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Reserve(void * jarg1, unsigned long jarg2) {
51406   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51407   Dali::Vector< int >::SizeType arg2 ;
51408
51409   arg1 = (Dali::Vector< int > *)jarg1;
51410   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51411   {
51412     try {
51413       (arg1)->Reserve(arg2);
51414     } catch (std::out_of_range& e) {
51415       {
51416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51417       };
51418     } catch (std::exception& e) {
51419       {
51420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51421       };
51422     } catch (Dali::DaliException e) {
51423       {
51424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51425       };
51426     } catch (...) {
51427       {
51428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51429       };
51430     }
51431   }
51432
51433 }
51434
51435
51436 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
51437   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51438   Dali::Vector< int >::SizeType arg2 ;
51439
51440   arg1 = (Dali::Vector< int > *)jarg1;
51441   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51442   {
51443     try {
51444       (arg1)->Resize(arg2);
51445     } catch (std::out_of_range& e) {
51446       {
51447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51448       };
51449     } catch (std::exception& e) {
51450       {
51451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51452       };
51453     } catch (Dali::DaliException e) {
51454       {
51455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51456       };
51457     } catch (...) {
51458       {
51459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51460       };
51461     }
51462   }
51463
51464 }
51465
51466
51467 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_1(void * jarg1, unsigned long jarg2, int jarg3) {
51468   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51469   Dali::Vector< int >::SizeType arg2 ;
51470   Dali::Vector< int >::ItemType *arg3 = 0 ;
51471   Dali::Vector< int >::ItemType temp3 ;
51472
51473   arg1 = (Dali::Vector< int > *)jarg1;
51474   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51475   temp3 = (Dali::Vector< int >::ItemType)jarg3;
51476   arg3 = &temp3;
51477   {
51478     try {
51479       (arg1)->Resize(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
51480     } catch (std::out_of_range& e) {
51481       {
51482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51483       };
51484     } catch (std::exception& e) {
51485       {
51486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51487       };
51488     } catch (Dali::DaliException e) {
51489       {
51490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51491       };
51492     } catch (...) {
51493       {
51494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51495       };
51496     }
51497   }
51498
51499 }
51500
51501
51502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_0(void * jarg1, void * jarg2) {
51503   void * jresult ;
51504   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51505   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51506   Dali::Vector< int >::Iterator result;
51507
51508   arg1 = (Dali::Vector< int > *)jarg1;
51509   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51510   {
51511     try {
51512       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2);
51513     } catch (std::out_of_range& e) {
51514       {
51515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51516       };
51517     } catch (std::exception& e) {
51518       {
51519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51520       };
51521     } catch (Dali::DaliException e) {
51522       {
51523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51524       };
51525     } catch (...) {
51526       {
51527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51528       };
51529     }
51530   }
51531
51532   jresult = (void *)result;
51533   return jresult;
51534 }
51535
51536
51537 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
51538   void * jresult ;
51539   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51540   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51541   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
51542   Dali::Vector< int >::Iterator result;
51543
51544   arg1 = (Dali::Vector< int > *)jarg1;
51545   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51546   arg3 = (Dali::Vector< int >::Iterator)jarg3;
51547   {
51548     try {
51549       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2,arg3);
51550     } catch (std::out_of_range& e) {
51551       {
51552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51553       };
51554     } catch (std::exception& e) {
51555       {
51556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51557       };
51558     } catch (Dali::DaliException e) {
51559       {
51560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51561       };
51562     } catch (...) {
51563       {
51564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51565       };
51566     }
51567   }
51568
51569   jresult = (void *)result;
51570   return jresult;
51571 }
51572
51573
51574 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Remove(void * jarg1, void * jarg2) {
51575   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51576   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51577
51578   arg1 = (Dali::Vector< int > *)jarg1;
51579   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51580   {
51581     try {
51582       (arg1)->Remove(arg2);
51583     } catch (std::out_of_range& e) {
51584       {
51585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51586       };
51587     } catch (std::exception& e) {
51588       {
51589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51590       };
51591     } catch (Dali::DaliException e) {
51592       {
51593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51594       };
51595     } catch (...) {
51596       {
51597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51598       };
51599     }
51600   }
51601
51602 }
51603
51604
51605 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Swap(void * jarg1, void * jarg2) {
51606   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51607   Dali::Vector< int > *arg2 = 0 ;
51608
51609   arg1 = (Dali::Vector< int > *)jarg1;
51610   arg2 = (Dali::Vector< int > *)jarg2;
51611   if (!arg2) {
51612     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > & type is null", 0);
51613     return ;
51614   }
51615   {
51616     try {
51617       (arg1)->Swap(*arg2);
51618     } catch (std::out_of_range& e) {
51619       {
51620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51621       };
51622     } catch (std::exception& e) {
51623       {
51624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51625       };
51626     } catch (Dali::DaliException e) {
51627       {
51628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51629       };
51630     } catch (...) {
51631       {
51632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51633       };
51634     }
51635   }
51636
51637 }
51638
51639
51640 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Clear(void * jarg1) {
51641   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51642
51643   arg1 = (Dali::Vector< int > *)jarg1;
51644   {
51645     try {
51646       (arg1)->Clear();
51647     } catch (std::out_of_range& e) {
51648       {
51649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51650       };
51651     } catch (std::exception& e) {
51652       {
51653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51654       };
51655     } catch (Dali::DaliException e) {
51656       {
51657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51658       };
51659     } catch (...) {
51660       {
51661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51662       };
51663     }
51664   }
51665
51666 }
51667
51668
51669 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Release(void * jarg1) {
51670   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51671
51672   arg1 = (Dali::Vector< int > *)jarg1;
51673   {
51674     try {
51675       (arg1)->Release();
51676     } catch (std::out_of_range& e) {
51677       {
51678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51679       };
51680     } catch (std::exception& e) {
51681       {
51682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51683       };
51684     } catch (Dali::DaliException e) {
51685       {
51686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51687       };
51688     } catch (...) {
51689       {
51690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51691       };
51692     }
51693   }
51694
51695 }
51696
51697
51698 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorFloat_BaseType_get() {
51699   int jresult ;
51700   int result;
51701
51702   result = (int)Dali::Vector< float >::BaseType;
51703   jresult = (int)result;
51704   return jresult;
51705 }
51706
51707
51708 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_0() {
51709   void * jresult ;
51710   Dali::Vector< float > *result = 0 ;
51711
51712   {
51713     try {
51714       result = (Dali::Vector< float > *)new Dali::Vector< float >();
51715     } catch (std::out_of_range& e) {
51716       {
51717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51718       };
51719     } catch (std::exception& e) {
51720       {
51721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51722       };
51723     } catch (Dali::DaliException e) {
51724       {
51725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51726       };
51727     } catch (...) {
51728       {
51729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51730       };
51731     }
51732   }
51733
51734   jresult = (void *)result;
51735   return jresult;
51736 }
51737
51738
51739 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorFloat(void * jarg1) {
51740   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51741
51742   arg1 = (Dali::Vector< float > *)jarg1;
51743   {
51744     try {
51745       delete arg1;
51746     } catch (std::out_of_range& e) {
51747       {
51748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51749       };
51750     } catch (std::exception& e) {
51751       {
51752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51753       };
51754     } catch (Dali::DaliException e) {
51755       {
51756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51757       };
51758     } catch (...) {
51759       {
51760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51761       };
51762     }
51763   }
51764
51765 }
51766
51767
51768 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_1(void * jarg1) {
51769   void * jresult ;
51770   Dali::Vector< float > *arg1 = 0 ;
51771   Dali::Vector< float > *result = 0 ;
51772
51773   arg1 = (Dali::Vector< float > *)jarg1;
51774   if (!arg1) {
51775     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
51776     return 0;
51777   }
51778   {
51779     try {
51780       result = (Dali::Vector< float > *)new Dali::Vector< float >((Dali::Vector< float > const &)*arg1);
51781     } catch (std::out_of_range& e) {
51782       {
51783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51784       };
51785     } catch (std::exception& e) {
51786       {
51787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51788       };
51789     } catch (Dali::DaliException e) {
51790       {
51791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51792       };
51793     } catch (...) {
51794       {
51795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51796       };
51797     }
51798   }
51799
51800   jresult = (void *)result;
51801   return jresult;
51802 }
51803
51804
51805 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Assign(void * jarg1, void * jarg2) {
51806   void * jresult ;
51807   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51808   Dali::Vector< float > *arg2 = 0 ;
51809   Dali::Vector< float > *result = 0 ;
51810
51811   arg1 = (Dali::Vector< float > *)jarg1;
51812   arg2 = (Dali::Vector< float > *)jarg2;
51813   if (!arg2) {
51814     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
51815     return 0;
51816   }
51817   {
51818     try {
51819       result = (Dali::Vector< float > *) &(arg1)->operator =((Dali::Vector< float > const &)*arg2);
51820     } catch (std::out_of_range& e) {
51821       {
51822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51823       };
51824     } catch (std::exception& e) {
51825       {
51826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51827       };
51828     } catch (Dali::DaliException e) {
51829       {
51830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51831       };
51832     } catch (...) {
51833       {
51834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51835       };
51836     }
51837   }
51838
51839   jresult = (void *)result;
51840   return jresult;
51841 }
51842
51843
51844 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Begin(void * jarg1) {
51845   void * jresult ;
51846   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51847   Dali::Vector< float >::Iterator result;
51848
51849   arg1 = (Dali::Vector< float > *)jarg1;
51850   {
51851     try {
51852       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->Begin();
51853     } catch (std::out_of_range& e) {
51854       {
51855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51856       };
51857     } catch (std::exception& e) {
51858       {
51859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51860       };
51861     } catch (Dali::DaliException e) {
51862       {
51863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51864       };
51865     } catch (...) {
51866       {
51867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51868       };
51869     }
51870   }
51871
51872   jresult = (void *)result;
51873   return jresult;
51874 }
51875
51876
51877 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_End(void * jarg1) {
51878   void * jresult ;
51879   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51880   Dali::Vector< float >::Iterator result;
51881
51882   arg1 = (Dali::Vector< float > *)jarg1;
51883   {
51884     try {
51885       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->End();
51886     } catch (std::out_of_range& e) {
51887       {
51888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51889       };
51890     } catch (std::exception& e) {
51891       {
51892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51893       };
51894     } catch (Dali::DaliException e) {
51895       {
51896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51897       };
51898     } catch (...) {
51899       {
51900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51901       };
51902     }
51903   }
51904
51905   jresult = (void *)result;
51906   return jresult;
51907 }
51908
51909
51910 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
51911   void * jresult ;
51912   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51913   Dali::Vector< float >::SizeType arg2 ;
51914   Dali::Vector< float >::ItemType *result = 0 ;
51915
51916   arg1 = (Dali::Vector< float > *)jarg1;
51917   arg2 = (Dali::Vector< float >::SizeType)jarg2;
51918   {
51919     try {
51920       result = (Dali::Vector< float >::ItemType *) &(arg1)->operator [](arg2);
51921     } catch (std::out_of_range& e) {
51922       {
51923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51924       };
51925     } catch (std::exception& e) {
51926       {
51927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51928       };
51929     } catch (Dali::DaliException e) {
51930       {
51931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51932       };
51933     } catch (...) {
51934       {
51935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51936       };
51937     }
51938   }
51939
51940   jresult = (void *)result;
51941   return jresult;
51942 }
51943
51944
51945 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_PushBack(void * jarg1, float jarg2) {
51946   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51947   Dali::Vector< float >::ItemType *arg2 = 0 ;
51948   Dali::Vector< float >::ItemType temp2 ;
51949
51950   arg1 = (Dali::Vector< float > *)jarg1;
51951   temp2 = (Dali::Vector< float >::ItemType)jarg2;
51952   arg2 = &temp2;
51953   {
51954     try {
51955       (arg1)->PushBack((Dali::Vector< float >::ItemType const &)*arg2);
51956     } catch (std::out_of_range& e) {
51957       {
51958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51959       };
51960     } catch (std::exception& e) {
51961       {
51962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51963       };
51964     } catch (Dali::DaliException e) {
51965       {
51966         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51967       };
51968     } catch (...) {
51969       {
51970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51971       };
51972     }
51973   }
51974
51975 }
51976
51977
51978 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_0(void * jarg1, void * jarg2, float jarg3) {
51979   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51980   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
51981   Dali::Vector< float >::ItemType *arg3 = 0 ;
51982   Dali::Vector< float >::ItemType temp3 ;
51983
51984   arg1 = (Dali::Vector< float > *)jarg1;
51985   arg2 = (Dali::Vector< float >::Iterator)jarg2;
51986   temp3 = (Dali::Vector< float >::ItemType)jarg3;
51987   arg3 = &temp3;
51988   {
51989     try {
51990       (arg1)->Insert(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
51991     } catch (std::out_of_range& e) {
51992       {
51993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51994       };
51995     } catch (std::exception& e) {
51996       {
51997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51998       };
51999     } catch (Dali::DaliException e) {
52000       {
52001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52002       };
52003     } catch (...) {
52004       {
52005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52006       };
52007     }
52008   }
52009
52010 }
52011
52012
52013 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
52014   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52015   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
52016   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
52017   Dali::Vector< float >::Iterator arg4 = (Dali::Vector< float >::Iterator) 0 ;
52018
52019   arg1 = (Dali::Vector< float > *)jarg1;
52020   arg2 = (Dali::Vector< float >::Iterator)jarg2;
52021   arg3 = (Dali::Vector< float >::Iterator)jarg3;
52022   arg4 = (Dali::Vector< float >::Iterator)jarg4;
52023   {
52024     try {
52025       (arg1)->Insert(arg2,arg3,arg4);
52026     } catch (std::out_of_range& e) {
52027       {
52028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52029       };
52030     } catch (std::exception& e) {
52031       {
52032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52033       };
52034     } catch (Dali::DaliException e) {
52035       {
52036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52037       };
52038     } catch (...) {
52039       {
52040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52041       };
52042     }
52043   }
52044
52045 }
52046
52047
52048 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Reserve(void * jarg1, unsigned long jarg2) {
52049   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52050   Dali::Vector< float >::SizeType arg2 ;
52051
52052   arg1 = (Dali::Vector< float > *)jarg1;
52053   arg2 = (Dali::Vector< float >::SizeType)jarg2;
52054   {
52055     try {
52056       (arg1)->Reserve(arg2);
52057     } catch (std::out_of_range& e) {
52058       {
52059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52060       };
52061     } catch (std::exception& e) {
52062       {
52063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52064       };
52065     } catch (Dali::DaliException e) {
52066       {
52067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52068       };
52069     } catch (...) {
52070       {
52071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52072       };
52073     }
52074   }
52075
52076 }
52077
52078 //// ========================= end of part 2 =============================
52079
52080 //// ========================== start part 3 ===============================
52081
52082
52083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
52084   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52085   Dali::Vector< float >::SizeType arg2 ;
52086
52087   arg1 = (Dali::Vector< float > *)jarg1;
52088   arg2 = (Dali::Vector< float >::SizeType)jarg2;
52089   {
52090     try {
52091       (arg1)->Resize(arg2);
52092     } catch (std::out_of_range& e) {
52093       {
52094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52095       };
52096     } catch (std::exception& e) {
52097       {
52098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52099       };
52100     } catch (Dali::DaliException e) {
52101       {
52102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52103       };
52104     } catch (...) {
52105       {
52106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52107       };
52108     }
52109   }
52110
52111 }
52112
52113
52114 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_1(void * jarg1, unsigned long jarg2, float jarg3) {
52115   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52116   Dali::Vector< float >::SizeType arg2 ;
52117   Dali::Vector< float >::ItemType *arg3 = 0 ;
52118   Dali::Vector< float >::ItemType temp3 ;
52119
52120   arg1 = (Dali::Vector< float > *)jarg1;
52121   arg2 = (Dali::Vector< float >::SizeType)jarg2;
52122   temp3 = (Dali::Vector< float >::ItemType)jarg3;
52123   arg3 = &temp3;
52124   {
52125     try {
52126       (arg1)->Resize(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
52127     } catch (std::out_of_range& e) {
52128       {
52129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52130       };
52131     } catch (std::exception& e) {
52132       {
52133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52134       };
52135     } catch (Dali::DaliException e) {
52136       {
52137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52138       };
52139     } catch (...) {
52140       {
52141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52142       };
52143     }
52144   }
52145
52146 }
52147
52148
52149 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_0(void * jarg1, void * jarg2) {
52150   void * jresult ;
52151   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52152   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
52153   Dali::Vector< float >::Iterator result;
52154
52155   arg1 = (Dali::Vector< float > *)jarg1;
52156   arg2 = (Dali::Vector< float >::Iterator)jarg2;
52157   {
52158     try {
52159       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2);
52160     } catch (std::out_of_range& e) {
52161       {
52162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52163       };
52164     } catch (std::exception& e) {
52165       {
52166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52167       };
52168     } catch (Dali::DaliException e) {
52169       {
52170         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52171       };
52172     } catch (...) {
52173       {
52174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52175       };
52176     }
52177   }
52178
52179   jresult = (void *)result;
52180   return jresult;
52181 }
52182
52183
52184 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
52185   void * jresult ;
52186   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52187   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
52188   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
52189   Dali::Vector< float >::Iterator result;
52190
52191   arg1 = (Dali::Vector< float > *)jarg1;
52192   arg2 = (Dali::Vector< float >::Iterator)jarg2;
52193   arg3 = (Dali::Vector< float >::Iterator)jarg3;
52194   {
52195     try {
52196       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2,arg3);
52197     } catch (std::out_of_range& e) {
52198       {
52199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52200       };
52201     } catch (std::exception& e) {
52202       {
52203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52204       };
52205     } catch (Dali::DaliException e) {
52206       {
52207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52208       };
52209     } catch (...) {
52210       {
52211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52212       };
52213     }
52214   }
52215
52216   jresult = (void *)result;
52217   return jresult;
52218 }
52219
52220
52221 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Remove(void * jarg1, void * jarg2) {
52222   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52223   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
52224
52225   arg1 = (Dali::Vector< float > *)jarg1;
52226   arg2 = (Dali::Vector< float >::Iterator)jarg2;
52227   {
52228     try {
52229       (arg1)->Remove(arg2);
52230     } catch (std::out_of_range& e) {
52231       {
52232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52233       };
52234     } catch (std::exception& e) {
52235       {
52236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52237       };
52238     } catch (Dali::DaliException e) {
52239       {
52240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52241       };
52242     } catch (...) {
52243       {
52244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52245       };
52246     }
52247   }
52248
52249 }
52250
52251
52252 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Swap(void * jarg1, void * jarg2) {
52253   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52254   Dali::Vector< float > *arg2 = 0 ;
52255
52256   arg1 = (Dali::Vector< float > *)jarg1;
52257   arg2 = (Dali::Vector< float > *)jarg2;
52258   if (!arg2) {
52259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > & type is null", 0);
52260     return ;
52261   }
52262   {
52263     try {
52264       (arg1)->Swap(*arg2);
52265     } catch (std::out_of_range& e) {
52266       {
52267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52268       };
52269     } catch (std::exception& e) {
52270       {
52271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52272       };
52273     } catch (Dali::DaliException e) {
52274       {
52275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52276       };
52277     } catch (...) {
52278       {
52279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52280       };
52281     }
52282   }
52283
52284 }
52285
52286
52287 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Clear(void * jarg1) {
52288   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52289
52290   arg1 = (Dali::Vector< float > *)jarg1;
52291   {
52292     try {
52293       (arg1)->Clear();
52294     } catch (std::out_of_range& e) {
52295       {
52296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52297       };
52298     } catch (std::exception& e) {
52299       {
52300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52301       };
52302     } catch (Dali::DaliException e) {
52303       {
52304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52305       };
52306     } catch (...) {
52307       {
52308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52309       };
52310     }
52311   }
52312
52313 }
52314
52315
52316 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Release(void * jarg1) {
52317   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52318
52319   arg1 = (Dali::Vector< float > *)jarg1;
52320   {
52321     try {
52322       (arg1)->Release();
52323     } catch (std::out_of_range& e) {
52324       {
52325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52326       };
52327     } catch (std::exception& e) {
52328       {
52329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52330       };
52331     } catch (Dali::DaliException e) {
52332       {
52333         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52334       };
52335     } catch (...) {
52336       {
52337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52338       };
52339     }
52340   }
52341
52342 }
52343
52344
52345 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_BaseType_get() {
52346   int jresult ;
52347   int result;
52348
52349   result = (int)Dali::Vector< unsigned char >::BaseType;
52350   jresult = (int)result;
52351   return jresult;
52352 }
52353
52354
52355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_0() {
52356   void * jresult ;
52357   Dali::Vector< unsigned char > *result = 0 ;
52358
52359   {
52360     try {
52361       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >();
52362     } catch (std::out_of_range& e) {
52363       {
52364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52365       };
52366     } catch (std::exception& e) {
52367       {
52368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52369       };
52370     } catch (Dali::DaliException e) {
52371       {
52372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52373       };
52374     } catch (...) {
52375       {
52376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52377       };
52378     }
52379   }
52380
52381   jresult = (void *)result;
52382   return jresult;
52383 }
52384
52385
52386 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUnsignedChar(void * jarg1) {
52387   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52388
52389   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52390   {
52391     try {
52392       delete arg1;
52393     } catch (std::out_of_range& e) {
52394       {
52395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52396       };
52397     } catch (std::exception& e) {
52398       {
52399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52400       };
52401     } catch (Dali::DaliException e) {
52402       {
52403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52404       };
52405     } catch (...) {
52406       {
52407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52408       };
52409     }
52410   }
52411
52412 }
52413
52414
52415 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_1(void * jarg1) {
52416   void * jresult ;
52417   Dali::Vector< unsigned char > *arg1 = 0 ;
52418   Dali::Vector< unsigned char > *result = 0 ;
52419
52420   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52421   if (!arg1) {
52422     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
52423     return 0;
52424   }
52425   {
52426     try {
52427       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >((Dali::Vector< unsigned char > const &)*arg1);
52428     } catch (std::out_of_range& e) {
52429       {
52430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52431       };
52432     } catch (std::exception& e) {
52433       {
52434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52435       };
52436     } catch (Dali::DaliException e) {
52437       {
52438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52439       };
52440     } catch (...) {
52441       {
52442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52443       };
52444     }
52445   }
52446
52447   jresult = (void *)result;
52448   return jresult;
52449 }
52450
52451
52452 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Assign(void * jarg1, void * jarg2) {
52453   void * jresult ;
52454   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52455   Dali::Vector< unsigned char > *arg2 = 0 ;
52456   Dali::Vector< unsigned char > *result = 0 ;
52457
52458   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52459   arg2 = (Dali::Vector< unsigned char > *)jarg2;
52460   if (!arg2) {
52461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
52462     return 0;
52463   }
52464   {
52465     try {
52466       result = (Dali::Vector< unsigned char > *) &(arg1)->operator =((Dali::Vector< unsigned char > const &)*arg2);
52467     } catch (std::out_of_range& e) {
52468       {
52469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52470       };
52471     } catch (std::exception& e) {
52472       {
52473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52474       };
52475     } catch (Dali::DaliException e) {
52476       {
52477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52478       };
52479     } catch (...) {
52480       {
52481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52482       };
52483     }
52484   }
52485
52486   jresult = (void *)result;
52487   return jresult;
52488 }
52489
52490
52491 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Begin(void * jarg1) {
52492   void * jresult ;
52493   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52494   Dali::Vector< unsigned char >::Iterator result;
52495
52496   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52497   {
52498     try {
52499       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->Begin();
52500     } catch (std::out_of_range& e) {
52501       {
52502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52503       };
52504     } catch (std::exception& e) {
52505       {
52506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52507       };
52508     } catch (Dali::DaliException e) {
52509       {
52510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52511       };
52512     } catch (...) {
52513       {
52514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52515       };
52516     }
52517   }
52518
52519   jresult = (void *)result;
52520   return jresult;
52521 }
52522
52523
52524 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_End(void * jarg1) {
52525   void * jresult ;
52526   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52527   Dali::Vector< unsigned char >::Iterator result;
52528
52529   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52530   {
52531     try {
52532       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->End();
52533     } catch (std::out_of_range& e) {
52534       {
52535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52536       };
52537     } catch (std::exception& e) {
52538       {
52539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52540       };
52541     } catch (Dali::DaliException e) {
52542       {
52543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52544       };
52545     } catch (...) {
52546       {
52547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52548       };
52549     }
52550   }
52551
52552   jresult = (void *)result;
52553   return jresult;
52554 }
52555
52556
52557 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
52558   void * jresult ;
52559   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52560   Dali::Vector< unsigned char >::SizeType arg2 ;
52561   Dali::Vector< unsigned char >::ItemType *result = 0 ;
52562
52563   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52564   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52565   {
52566     try {
52567       result = (Dali::Vector< unsigned char >::ItemType *) &(arg1)->operator [](arg2);
52568     } catch (std::out_of_range& e) {
52569       {
52570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52571       };
52572     } catch (std::exception& e) {
52573       {
52574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52575       };
52576     } catch (Dali::DaliException e) {
52577       {
52578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52579       };
52580     } catch (...) {
52581       {
52582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52583       };
52584     }
52585   }
52586
52587   jresult = (void *)result;
52588   return jresult;
52589 }
52590
52591
52592 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_PushBack(void * jarg1, unsigned char jarg2) {
52593   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52594   Dali::Vector< unsigned char >::ItemType *arg2 = 0 ;
52595   Dali::Vector< unsigned char >::ItemType temp2 ;
52596
52597   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52598   temp2 = (Dali::Vector< unsigned char >::ItemType)jarg2;
52599   arg2 = &temp2;
52600   {
52601     try {
52602       (arg1)->PushBack((Dali::Vector< unsigned char >::ItemType const &)*arg2);
52603     } catch (std::out_of_range& e) {
52604       {
52605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52606       };
52607     } catch (std::exception& e) {
52608       {
52609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52610       };
52611     } catch (Dali::DaliException e) {
52612       {
52613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52614       };
52615     } catch (...) {
52616       {
52617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52618       };
52619     }
52620   }
52621
52622 }
52623
52624
52625 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_0(void * jarg1, unsigned char* jarg2, unsigned char jarg3) {
52626   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52627   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52628   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
52629   Dali::Vector< unsigned char >::ItemType temp3 ;
52630
52631   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52632   arg2 = jarg2;
52633   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
52634   arg3 = &temp3;
52635   {
52636     try {
52637       (arg1)->Insert(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
52638     } catch (std::out_of_range& e) {
52639       {
52640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52641       };
52642     } catch (std::exception& e) {
52643       {
52644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52645       };
52646     } catch (Dali::DaliException e) {
52647       {
52648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52649       };
52650     } catch (...) {
52651       {
52652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52653       };
52654     }
52655   }
52656
52657
52658
52659 }
52660
52661
52662 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3, void * jarg4) {
52663   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52664   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52665   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52666   Dali::Vector< unsigned char >::Iterator arg4 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52667
52668   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52669   arg2 = jarg2;
52670   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
52671   arg4 = (Dali::Vector< unsigned char >::Iterator)jarg4;
52672   {
52673     try {
52674       (arg1)->Insert(arg2,arg3,arg4);
52675     } catch (std::out_of_range& e) {
52676       {
52677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52678       };
52679     } catch (std::exception& e) {
52680       {
52681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52682       };
52683     } catch (Dali::DaliException e) {
52684       {
52685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52686       };
52687     } catch (...) {
52688       {
52689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52690       };
52691     }
52692   }
52693
52694
52695
52696 }
52697
52698
52699 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Reserve(void * jarg1, unsigned long jarg2) {
52700   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52701   Dali::Vector< unsigned char >::SizeType arg2 ;
52702
52703   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52704   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52705   {
52706     try {
52707       (arg1)->Reserve(arg2);
52708     } catch (std::out_of_range& e) {
52709       {
52710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52711       };
52712     } catch (std::exception& e) {
52713       {
52714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52715       };
52716     } catch (Dali::DaliException e) {
52717       {
52718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52719       };
52720     } catch (...) {
52721       {
52722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52723       };
52724     }
52725   }
52726
52727 }
52728
52729
52730 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
52731   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52732   Dali::Vector< unsigned char >::SizeType arg2 ;
52733
52734   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52735   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52736   {
52737     try {
52738       (arg1)->Resize(arg2);
52739     } catch (std::out_of_range& e) {
52740       {
52741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52742       };
52743     } catch (std::exception& e) {
52744       {
52745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52746       };
52747     } catch (Dali::DaliException e) {
52748       {
52749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52750       };
52751     } catch (...) {
52752       {
52753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52754       };
52755     }
52756   }
52757
52758 }
52759
52760
52761 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_1(void * jarg1, unsigned long jarg2, unsigned char jarg3) {
52762   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52763   Dali::Vector< unsigned char >::SizeType arg2 ;
52764   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
52765   Dali::Vector< unsigned char >::ItemType temp3 ;
52766
52767   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52768   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52769   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
52770   arg3 = &temp3;
52771   {
52772     try {
52773       (arg1)->Resize(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
52774     } catch (std::out_of_range& e) {
52775       {
52776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52777       };
52778     } catch (std::exception& e) {
52779       {
52780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52781       };
52782     } catch (Dali::DaliException e) {
52783       {
52784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52785       };
52786     } catch (...) {
52787       {
52788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52789       };
52790     }
52791   }
52792
52793 }
52794
52795
52796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_0(void * jarg1, unsigned char* jarg2) {
52797   void * jresult ;
52798   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52799   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52800   Dali::Vector< unsigned char >::Iterator result;
52801
52802   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52803   arg2 = jarg2;
52804   {
52805     try {
52806       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2);
52807     } catch (std::out_of_range& e) {
52808       {
52809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52810       };
52811     } catch (std::exception& e) {
52812       {
52813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52814       };
52815     } catch (Dali::DaliException e) {
52816       {
52817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52818       };
52819     } catch (...) {
52820       {
52821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52822       };
52823     }
52824   }
52825
52826   jresult = (void *)result;
52827
52828
52829   return jresult;
52830 }
52831
52832
52833 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3) {
52834   void * jresult ;
52835   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52836   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52837   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52838   Dali::Vector< unsigned char >::Iterator result;
52839
52840   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52841   arg2 = jarg2;
52842   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
52843   {
52844     try {
52845       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2,arg3);
52846     } catch (std::out_of_range& e) {
52847       {
52848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52849       };
52850     } catch (std::exception& e) {
52851       {
52852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52853       };
52854     } catch (Dali::DaliException e) {
52855       {
52856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52857       };
52858     } catch (...) {
52859       {
52860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52861       };
52862     }
52863   }
52864
52865   jresult = (void *)result;
52866
52867
52868   return jresult;
52869 }
52870
52871
52872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Remove(void * jarg1, unsigned char* jarg2) {
52873   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52874   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52875
52876   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52877   arg2 = jarg2;
52878   {
52879     try {
52880       (arg1)->Remove(arg2);
52881     } catch (std::out_of_range& e) {
52882       {
52883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52884       };
52885     } catch (std::exception& e) {
52886       {
52887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52888       };
52889     } catch (Dali::DaliException e) {
52890       {
52891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52892       };
52893     } catch (...) {
52894       {
52895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52896       };
52897     }
52898   }
52899
52900
52901
52902 }
52903
52904
52905 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Swap(void * jarg1, void * jarg2) {
52906   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52907   Dali::Vector< unsigned char > *arg2 = 0 ;
52908
52909   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52910   arg2 = (Dali::Vector< unsigned char > *)jarg2;
52911   if (!arg2) {
52912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > & type is null", 0);
52913     return ;
52914   }
52915   {
52916     try {
52917       (arg1)->Swap(*arg2);
52918     } catch (std::out_of_range& e) {
52919       {
52920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52921       };
52922     } catch (std::exception& e) {
52923       {
52924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52925       };
52926     } catch (Dali::DaliException e) {
52927       {
52928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52929       };
52930     } catch (...) {
52931       {
52932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52933       };
52934     }
52935   }
52936
52937 }
52938
52939
52940 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Clear(void * jarg1) {
52941   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52942
52943   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52944   {
52945     try {
52946       (arg1)->Clear();
52947     } catch (std::out_of_range& e) {
52948       {
52949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52950       };
52951     } catch (std::exception& e) {
52952       {
52953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52954       };
52955     } catch (Dali::DaliException e) {
52956       {
52957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52958       };
52959     } catch (...) {
52960       {
52961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52962       };
52963     }
52964   }
52965
52966 }
52967
52968
52969 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Release(void * jarg1) {
52970   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52971
52972   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52973   {
52974     try {
52975       (arg1)->Release();
52976     } catch (std::out_of_range& e) {
52977       {
52978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52979       };
52980     } catch (std::exception& e) {
52981       {
52982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52983       };
52984     } catch (Dali::DaliException e) {
52985       {
52986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52987       };
52988     } catch (...) {
52989       {
52990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52991       };
52992     }
52993   }
52994
52995 }
52996
52997
52998 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUint16Pair_BaseType_get() {
52999   int jresult ;
53000   int result;
53001
53002   result = (int)Dali::Vector< Dali::Uint16Pair >::BaseType;
53003   jresult = (int)result;
53004   return jresult;
53005 }
53006
53007
53008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_0() {
53009   void * jresult ;
53010   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
53011
53012   {
53013     try {
53014       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >();
53015     } catch (std::out_of_range& e) {
53016       {
53017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53018       };
53019     } catch (std::exception& e) {
53020       {
53021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53022       };
53023     } catch (Dali::DaliException e) {
53024       {
53025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53026       };
53027     } catch (...) {
53028       {
53029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53030       };
53031     }
53032   }
53033
53034   jresult = (void *)result;
53035   return jresult;
53036 }
53037
53038
53039 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUint16Pair(void * jarg1) {
53040   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53041
53042   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53043   {
53044     try {
53045       delete arg1;
53046     } catch (std::out_of_range& e) {
53047       {
53048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53049       };
53050     } catch (std::exception& e) {
53051       {
53052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53053       };
53054     } catch (Dali::DaliException e) {
53055       {
53056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53057       };
53058     } catch (...) {
53059       {
53060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53061       };
53062     }
53063   }
53064
53065 }
53066
53067
53068 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_1(void * jarg1) {
53069   void * jresult ;
53070   Dali::Vector< Dali::Uint16Pair > *arg1 = 0 ;
53071   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
53072
53073   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53074   if (!arg1) {
53075     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
53076     return 0;
53077   }
53078   {
53079     try {
53080       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >((Dali::Vector< Dali::Uint16Pair > const &)*arg1);
53081     } catch (std::out_of_range& e) {
53082       {
53083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53084       };
53085     } catch (std::exception& e) {
53086       {
53087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53088       };
53089     } catch (Dali::DaliException e) {
53090       {
53091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53092       };
53093     } catch (...) {
53094       {
53095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53096       };
53097     }
53098   }
53099
53100   jresult = (void *)result;
53101   return jresult;
53102 }
53103
53104
53105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Assign(void * jarg1, void * jarg2) {
53106   void * jresult ;
53107   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53108   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
53109   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
53110
53111   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53112   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
53113   if (!arg2) {
53114     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
53115     return 0;
53116   }
53117   {
53118     try {
53119       result = (Dali::Vector< Dali::Uint16Pair > *) &(arg1)->operator =((Dali::Vector< Dali::Uint16Pair > const &)*arg2);
53120     } catch (std::out_of_range& e) {
53121       {
53122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53123       };
53124     } catch (std::exception& e) {
53125       {
53126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53127       };
53128     } catch (Dali::DaliException e) {
53129       {
53130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53131       };
53132     } catch (...) {
53133       {
53134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53135       };
53136     }
53137   }
53138
53139   jresult = (void *)result;
53140   return jresult;
53141 }
53142
53143
53144 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Begin(void * jarg1) {
53145   void * jresult ;
53146   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53147   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53148
53149   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53150   {
53151     try {
53152       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->Begin();
53153     } catch (std::out_of_range& e) {
53154       {
53155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53156       };
53157     } catch (std::exception& e) {
53158       {
53159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53160       };
53161     } catch (Dali::DaliException e) {
53162       {
53163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53164       };
53165     } catch (...) {
53166       {
53167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53168       };
53169     }
53170   }
53171
53172   jresult = (void *)result;
53173   return jresult;
53174 }
53175
53176
53177 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_End(void * jarg1) {
53178   void * jresult ;
53179   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53180   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53181
53182   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53183   {
53184     try {
53185       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->End();
53186     } catch (std::out_of_range& e) {
53187       {
53188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53189       };
53190     } catch (std::exception& e) {
53191       {
53192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53193       };
53194     } catch (Dali::DaliException e) {
53195       {
53196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53197       };
53198     } catch (...) {
53199       {
53200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53201       };
53202     }
53203   }
53204
53205   jresult = (void *)result;
53206   return jresult;
53207 }
53208
53209
53210 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
53211   void * jresult ;
53212   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53213   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53214   Dali::Vector< Dali::Uint16Pair >::ItemType *result = 0 ;
53215
53216   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53217   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53218   {
53219     try {
53220       result = (Dali::Vector< Dali::Uint16Pair >::ItemType *) &(arg1)->operator [](arg2);
53221     } catch (std::out_of_range& e) {
53222       {
53223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53224       };
53225     } catch (std::exception& e) {
53226       {
53227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53228       };
53229     } catch (Dali::DaliException e) {
53230       {
53231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53232       };
53233     } catch (...) {
53234       {
53235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53236       };
53237     }
53238   }
53239
53240   jresult = (void *)result;
53241   return jresult;
53242 }
53243
53244
53245 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_PushBack(void * jarg1, void * jarg2) {
53246   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53247   Dali::Vector< Dali::Uint16Pair >::ItemType *arg2 = 0 ;
53248
53249   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53250   arg2 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg2;
53251   if (!arg2) {
53252     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
53253     return ;
53254   }
53255   {
53256     try {
53257       (arg1)->PushBack((Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg2);
53258     } catch (std::out_of_range& e) {
53259       {
53260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53261       };
53262     } catch (std::exception& e) {
53263       {
53264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53265       };
53266     } catch (Dali::DaliException e) {
53267       {
53268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53269       };
53270     } catch (...) {
53271       {
53272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53273       };
53274     }
53275   }
53276
53277 }
53278
53279
53280 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
53281   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53282   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53283   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
53284
53285   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53286   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53287   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
53288   if (!arg3) {
53289     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
53290     return ;
53291   }
53292   {
53293     try {
53294       (arg1)->Insert(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
53295     } catch (std::out_of_range& e) {
53296       {
53297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53298       };
53299     } catch (std::exception& e) {
53300       {
53301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53302       };
53303     } catch (Dali::DaliException e) {
53304       {
53305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53306       };
53307     } catch (...) {
53308       {
53309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53310       };
53311     }
53312   }
53313
53314 }
53315
53316
53317 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
53318   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53319   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53320   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53321   Dali::Vector< Dali::Uint16Pair >::Iterator arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53322
53323   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53324   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53325   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
53326   arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg4;
53327   {
53328     try {
53329       (arg1)->Insert(arg2,arg3,arg4);
53330     } catch (std::out_of_range& e) {
53331       {
53332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53333       };
53334     } catch (std::exception& e) {
53335       {
53336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53337       };
53338     } catch (Dali::DaliException e) {
53339       {
53340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53341       };
53342     } catch (...) {
53343       {
53344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53345       };
53346     }
53347   }
53348
53349 }
53350
53351
53352 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Reserve(void * jarg1, unsigned long jarg2) {
53353   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53354   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53355
53356   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53357   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53358   {
53359     try {
53360       (arg1)->Reserve(arg2);
53361     } catch (std::out_of_range& e) {
53362       {
53363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53364       };
53365     } catch (std::exception& e) {
53366       {
53367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53368       };
53369     } catch (Dali::DaliException e) {
53370       {
53371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53372       };
53373     } catch (...) {
53374       {
53375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53376       };
53377     }
53378   }
53379
53380 }
53381
53382
53383 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
53384   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53385   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53386
53387   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53388   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53389   {
53390     try {
53391       (arg1)->Resize(arg2);
53392     } catch (std::out_of_range& e) {
53393       {
53394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53395       };
53396     } catch (std::exception& e) {
53397       {
53398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53399       };
53400     } catch (Dali::DaliException e) {
53401       {
53402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53403       };
53404     } catch (...) {
53405       {
53406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53407       };
53408     }
53409   }
53410
53411 }
53412
53413
53414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3) {
53415   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53416   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53417   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
53418
53419   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53420   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53421   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
53422   if (!arg3) {
53423     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
53424     return ;
53425   }
53426   {
53427     try {
53428       (arg1)->Resize(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
53429     } catch (std::out_of_range& e) {
53430       {
53431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53432       };
53433     } catch (std::exception& e) {
53434       {
53435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53436       };
53437     } catch (Dali::DaliException e) {
53438       {
53439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53440       };
53441     } catch (...) {
53442       {
53443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53444       };
53445     }
53446   }
53447
53448 }
53449
53450
53451 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_0(void * jarg1, void * jarg2) {
53452   void * jresult ;
53453   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53454   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53455   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53456
53457   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53458   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53459   {
53460     try {
53461       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2);
53462     } catch (std::out_of_range& e) {
53463       {
53464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53465       };
53466     } catch (std::exception& e) {
53467       {
53468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53469       };
53470     } catch (Dali::DaliException e) {
53471       {
53472         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53473       };
53474     } catch (...) {
53475       {
53476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53477       };
53478     }
53479   }
53480
53481   jresult = (void *)result;
53482   return jresult;
53483 }
53484
53485
53486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
53487   void * jresult ;
53488   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53489   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53490   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53491   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53492
53493   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53494   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53495   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
53496   {
53497     try {
53498       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2,arg3);
53499     } catch (std::out_of_range& e) {
53500       {
53501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53502       };
53503     } catch (std::exception& e) {
53504       {
53505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53506       };
53507     } catch (Dali::DaliException e) {
53508       {
53509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53510       };
53511     } catch (...) {
53512       {
53513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53514       };
53515     }
53516   }
53517
53518   jresult = (void *)result;
53519   return jresult;
53520 }
53521
53522
53523 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Remove(void * jarg1, void * jarg2) {
53524   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53525   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53526
53527   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53528   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53529   {
53530     try {
53531       (arg1)->Remove(arg2);
53532     } catch (std::out_of_range& e) {
53533       {
53534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53535       };
53536     } catch (std::exception& e) {
53537       {
53538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53539       };
53540     } catch (Dali::DaliException e) {
53541       {
53542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53543       };
53544     } catch (...) {
53545       {
53546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53547       };
53548     }
53549   }
53550
53551 }
53552
53553
53554 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Swap(void * jarg1, void * jarg2) {
53555   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53556   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
53557
53558   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53559   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
53560   if (!arg2) {
53561     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > & type is null", 0);
53562     return ;
53563   }
53564   {
53565     try {
53566       (arg1)->Swap(*arg2);
53567     } catch (std::out_of_range& e) {
53568       {
53569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53570       };
53571     } catch (std::exception& e) {
53572       {
53573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53574       };
53575     } catch (Dali::DaliException e) {
53576       {
53577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53578       };
53579     } catch (...) {
53580       {
53581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53582       };
53583     }
53584   }
53585
53586 }
53587
53588
53589 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Clear(void * jarg1) {
53590   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53591
53592   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53593   {
53594     try {
53595       (arg1)->Clear();
53596     } catch (std::out_of_range& e) {
53597       {
53598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53599       };
53600     } catch (std::exception& e) {
53601       {
53602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53603       };
53604     } catch (Dali::DaliException e) {
53605       {
53606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53607       };
53608     } catch (...) {
53609       {
53610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53611       };
53612     }
53613   }
53614
53615 }
53616
53617
53618 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Release(void * jarg1) {
53619   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53620
53621   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53622   {
53623     try {
53624       (arg1)->Release();
53625     } catch (std::out_of_range& e) {
53626       {
53627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53628       };
53629     } catch (std::exception& e) {
53630       {
53631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53632       };
53633     } catch (Dali::DaliException e) {
53634       {
53635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53636       };
53637     } catch (...) {
53638       {
53639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53640       };
53641     }
53642   }
53643
53644 }
53645
53646
53647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VoidSignal() {
53648   void * jresult ;
53649   Dali::Signal< void () > *result = 0 ;
53650
53651   {
53652     try {
53653       result = (Dali::Signal< void () > *)new Dali::Signal< void () >();
53654     } catch (std::out_of_range& e) {
53655       {
53656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53657       };
53658     } catch (std::exception& e) {
53659       {
53660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53661       };
53662     } catch (Dali::DaliException e) {
53663       {
53664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53665       };
53666     } catch (...) {
53667       {
53668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53669       };
53670     }
53671   }
53672
53673   jresult = (void *)result;
53674   return jresult;
53675 }
53676
53677
53678 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VoidSignal(void * jarg1) {
53679   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53680
53681   arg1 = (Dali::Signal< void () > *)jarg1;
53682   {
53683     try {
53684       delete arg1;
53685     } catch (std::out_of_range& e) {
53686       {
53687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53688       };
53689     } catch (std::exception& e) {
53690       {
53691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53692       };
53693     } catch (Dali::DaliException e) {
53694       {
53695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53696       };
53697     } catch (...) {
53698       {
53699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53700       };
53701     }
53702   }
53703
53704 }
53705
53706
53707 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VoidSignal_Empty(void * jarg1) {
53708   unsigned int jresult ;
53709   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53710   bool result;
53711
53712   arg1 = (Dali::Signal< void () > *)jarg1;
53713   {
53714     try {
53715       result = (bool)((Dali::Signal< void () > const *)arg1)->Empty();
53716     } catch (std::out_of_range& e) {
53717       {
53718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53719       };
53720     } catch (std::exception& e) {
53721       {
53722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53723       };
53724     } catch (Dali::DaliException e) {
53725       {
53726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53727       };
53728     } catch (...) {
53729       {
53730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53731       };
53732     }
53733   }
53734
53735   jresult = result;
53736   return jresult;
53737 }
53738
53739
53740 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VoidSignal_GetConnectionCount(void * jarg1) {
53741   unsigned long jresult ;
53742   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53743   std::size_t result;
53744
53745   arg1 = (Dali::Signal< void () > *)jarg1;
53746   {
53747     try {
53748       result = ((Dali::Signal< void () > const *)arg1)->GetConnectionCount();
53749     } catch (std::out_of_range& e) {
53750       {
53751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53752       };
53753     } catch (std::exception& e) {
53754       {
53755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53756       };
53757     } catch (Dali::DaliException e) {
53758       {
53759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53760       };
53761     } catch (...) {
53762       {
53763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53764       };
53765     }
53766   }
53767
53768   jresult = (unsigned long)result;
53769   return jresult;
53770 }
53771
53772
53773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_0(void * jarg1, void * jarg2) {
53774   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53775   void (*arg2)() = (void (*)()) 0 ;
53776
53777   arg1 = (Dali::Signal< void () > *)jarg1;
53778   arg2 = (void (*)())jarg2;
53779   {
53780     try {
53781       (arg1)->Connect(arg2);
53782     } catch (std::out_of_range& e) {
53783       {
53784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53785       };
53786     } catch (std::exception& e) {
53787       {
53788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53789       };
53790     } catch (Dali::DaliException e) {
53791       {
53792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53793       };
53794     } catch (...) {
53795       {
53796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53797       };
53798     }
53799   }
53800
53801 }
53802
53803
53804 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Disconnect(void * jarg1, void * jarg2) {
53805   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53806   void (*arg2)() = (void (*)()) 0 ;
53807
53808   arg1 = (Dali::Signal< void () > *)jarg1;
53809   arg2 = (void (*)())jarg2;
53810   {
53811     try {
53812       (arg1)->Disconnect(arg2);
53813     } catch (std::out_of_range& e) {
53814       {
53815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53816       };
53817     } catch (std::exception& e) {
53818       {
53819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53820       };
53821     } catch (Dali::DaliException e) {
53822       {
53823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53824       };
53825     } catch (...) {
53826       {
53827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53828       };
53829     }
53830   }
53831
53832 }
53833
53834
53835 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
53836   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53837   Dali::ConnectionTrackerInterface *arg2 = (Dali::ConnectionTrackerInterface *) 0 ;
53838   Dali::FunctorDelegate *arg3 = (Dali::FunctorDelegate *) 0 ;
53839
53840   arg1 = (Dali::Signal< void () > *)jarg1;
53841   arg2 = (Dali::ConnectionTrackerInterface *)jarg2;
53842   arg3 = (Dali::FunctorDelegate *)jarg3;
53843   {
53844     try {
53845       (arg1)->Connect(arg2,arg3);
53846     } catch (std::out_of_range& e) {
53847       {
53848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53849       };
53850     } catch (std::exception& e) {
53851       {
53852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53853       };
53854     } catch (Dali::DaliException e) {
53855       {
53856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53857       };
53858     } catch (...) {
53859       {
53860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53861       };
53862     }
53863   }
53864
53865 }
53866
53867
53868 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Emit(void * jarg1) {
53869   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53870
53871   arg1 = (Dali::Signal< void () > *)jarg1;
53872   {
53873     try {
53874       (arg1)->Emit();
53875     } catch (std::out_of_range& e) {
53876       {
53877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53878       };
53879     } catch (std::exception& e) {
53880       {
53881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53882       };
53883     } catch (Dali::DaliException e) {
53884       {
53885         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53886       };
53887     } catch (...) {
53888       {
53889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53890       };
53891     }
53892   }
53893
53894 }
53895
53896
53897 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FloatSignal_Empty(void * jarg1) {
53898   unsigned int jresult ;
53899   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
53900   bool result;
53901
53902   arg1 = (Dali::Signal< void (float) > *)jarg1;
53903   {
53904     try {
53905       result = (bool)Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty((Dali::Signal< void (float) > const *)arg1);
53906     } catch (std::out_of_range& e) {
53907       {
53908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53909       };
53910     } catch (std::exception& e) {
53911       {
53912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53913       };
53914     } catch (Dali::DaliException e) {
53915       {
53916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53917       };
53918     } catch (...) {
53919       {
53920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53921       };
53922     }
53923   }
53924
53925   jresult = result;
53926   return jresult;
53927 }
53928
53929
53930 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FloatSignal_GetConnectionCount(void * jarg1) {
53931   unsigned long jresult ;
53932   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
53933   std::size_t result;
53934
53935   arg1 = (Dali::Signal< void (float) > *)jarg1;
53936   {
53937     try {
53938       result = Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount((Dali::Signal< void (float) > const *)arg1);
53939     } catch (std::out_of_range& e) {
53940       {
53941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53942       };
53943     } catch (std::exception& e) {
53944       {
53945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53946       };
53947     } catch (Dali::DaliException e) {
53948       {
53949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53950       };
53951     } catch (...) {
53952       {
53953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53954       };
53955     }
53956   }
53957
53958   jresult = (unsigned long)result;
53959   return jresult;
53960 }
53961
53962
53963 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Connect(void * jarg1, void * jarg2) {
53964   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
53965   void (*arg2)(float) = (void (*)(float)) 0 ;
53966
53967   arg1 = (Dali::Signal< void (float) > *)jarg1;
53968   arg2 = (void (*)(float))jarg2;
53969   {
53970     try {
53971       Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(arg1,arg2);
53972     } catch (std::out_of_range& e) {
53973       {
53974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53975       };
53976     } catch (std::exception& e) {
53977       {
53978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53979       };
53980     } catch (Dali::DaliException e) {
53981       {
53982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53983       };
53984     } catch (...) {
53985       {
53986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53987       };
53988     }
53989   }
53990
53991 }
53992
53993
53994 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Disconnect(void * jarg1, void * jarg2) {
53995   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
53996   void (*arg2)(float) = (void (*)(float)) 0 ;
53997
53998   arg1 = (Dali::Signal< void (float) > *)jarg1;
53999   arg2 = (void (*)(float))jarg2;
54000   {
54001     try {
54002       Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(arg1,arg2);
54003     } catch (std::out_of_range& e) {
54004       {
54005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54006       };
54007     } catch (std::exception& e) {
54008       {
54009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54010       };
54011     } catch (Dali::DaliException e) {
54012       {
54013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54014       };
54015     } catch (...) {
54016       {
54017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54018       };
54019     }
54020   }
54021
54022 }
54023
54024
54025 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Emit(void * jarg1, float jarg2) {
54026   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
54027   float arg2 ;
54028
54029   arg1 = (Dali::Signal< void (float) > *)jarg1;
54030   arg2 = (float)jarg2;
54031   {
54032     try {
54033       Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(arg1,arg2);
54034     } catch (std::out_of_range& e) {
54035       {
54036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54037       };
54038     } catch (std::exception& e) {
54039       {
54040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54041       };
54042     } catch (Dali::DaliException e) {
54043       {
54044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54045       };
54046     } catch (...) {
54047       {
54048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54049       };
54050     }
54051   }
54052
54053 }
54054
54055
54056 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FloatSignal() {
54057   void * jresult ;
54058   Dali::Signal< void (float) > *result = 0 ;
54059
54060   {
54061     try {
54062       result = (Dali::Signal< void (float) > *)new Dali::Signal< void (float) >();
54063     } catch (std::out_of_range& e) {
54064       {
54065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54066       };
54067     } catch (std::exception& e) {
54068       {
54069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54070       };
54071     } catch (Dali::DaliException e) {
54072       {
54073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54074       };
54075     } catch (...) {
54076       {
54077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54078       };
54079     }
54080   }
54081
54082   jresult = (void *)result;
54083   return jresult;
54084 }
54085
54086
54087 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FloatSignal(void * jarg1) {
54088   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
54089
54090   arg1 = (Dali::Signal< void (float) > *)jarg1;
54091   {
54092     try {
54093       delete arg1;
54094     } catch (std::out_of_range& e) {
54095       {
54096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54097       };
54098     } catch (std::exception& e) {
54099       {
54100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54101       };
54102     } catch (Dali::DaliException e) {
54103       {
54104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54105       };
54106     } catch (...) {
54107       {
54108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54109       };
54110     }
54111   }
54112
54113 }
54114
54115
54116 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Empty(void * jarg1) {
54117   unsigned int jresult ;
54118   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54119   bool result;
54120
54121   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54122   {
54123     try {
54124       result = (bool)Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
54125     } catch (std::out_of_range& e) {
54126       {
54127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54128       };
54129     } catch (std::exception& e) {
54130       {
54131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54132       };
54133     } catch (Dali::DaliException e) {
54134       {
54135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54136       };
54137     } catch (...) {
54138       {
54139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54140       };
54141     }
54142   }
54143
54144   jresult = result;
54145   return jresult;
54146 }
54147
54148
54149 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_GetConnectionCount(void * jarg1) {
54150   unsigned long jresult ;
54151   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54152   std::size_t result;
54153
54154   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54155   {
54156     try {
54157       result = Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
54158     } catch (std::out_of_range& e) {
54159       {
54160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54161       };
54162     } catch (std::exception& e) {
54163       {
54164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54165       };
54166     } catch (Dali::DaliException e) {
54167       {
54168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54169       };
54170     } catch (...) {
54171       {
54172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54173       };
54174     }
54175   }
54176
54177   jresult = (unsigned long)result;
54178   return jresult;
54179 }
54180
54181
54182 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Connect(void * jarg1, void * jarg2) {
54183   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54184   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
54185
54186   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54187   arg2 = (void (*)(Dali::BaseHandle))jarg2;
54188   {
54189     try {
54190       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(arg1,arg2);
54191     } catch (std::out_of_range& e) {
54192       {
54193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54194       };
54195     } catch (std::exception& e) {
54196       {
54197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54198       };
54199     } catch (Dali::DaliException e) {
54200       {
54201         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54202       };
54203     } catch (...) {
54204       {
54205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54206       };
54207     }
54208   }
54209
54210 }
54211
54212
54213 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Disconnect(void * jarg1, void * jarg2) {
54214   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54215   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
54216
54217   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54218   arg2 = (void (*)(Dali::BaseHandle))jarg2;
54219   {
54220     try {
54221       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(arg1,arg2);
54222     } catch (std::out_of_range& e) {
54223       {
54224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54225       };
54226     } catch (std::exception& e) {
54227       {
54228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54229       };
54230     } catch (Dali::DaliException e) {
54231       {
54232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54233       };
54234     } catch (...) {
54235       {
54236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54237       };
54238     }
54239   }
54240
54241 }
54242
54243
54244 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Emit(void * jarg1, void * jarg2) {
54245   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54246   Dali::BaseHandle arg2 ;
54247   Dali::BaseHandle *argp2 ;
54248
54249   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54250   argp2 = (Dali::BaseHandle *)jarg2;
54251   if (!argp2) {
54252     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
54253     return ;
54254   }
54255   arg2 = *argp2;
54256   {
54257     try {
54258       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(arg1,arg2);
54259     } catch (std::out_of_range& e) {
54260       {
54261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54262       };
54263     } catch (std::exception& e) {
54264       {
54265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54266       };
54267     } catch (Dali::DaliException e) {
54268       {
54269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54270       };
54271     } catch (...) {
54272       {
54273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54274       };
54275     }
54276   }
54277
54278 }
54279
54280
54281 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectCreatedSignal() {
54282   void * jresult ;
54283   Dali::Signal< void (Dali::BaseHandle) > *result = 0 ;
54284
54285   {
54286     try {
54287       result = (Dali::Signal< void (Dali::BaseHandle) > *)new Dali::Signal< void (Dali::BaseHandle) >();
54288     } catch (std::out_of_range& e) {
54289       {
54290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54291       };
54292     } catch (std::exception& e) {
54293       {
54294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54295       };
54296     } catch (Dali::DaliException e) {
54297       {
54298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54299       };
54300     } catch (...) {
54301       {
54302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54303       };
54304     }
54305   }
54306
54307   jresult = (void *)result;
54308   return jresult;
54309 }
54310
54311
54312 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectCreatedSignal(void * jarg1) {
54313   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54314
54315   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54316   {
54317     try {
54318       delete arg1;
54319     } catch (std::out_of_range& e) {
54320       {
54321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54322       };
54323     } catch (std::exception& e) {
54324       {
54325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54326       };
54327     } catch (Dali::DaliException e) {
54328       {
54329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54330       };
54331     } catch (...) {
54332       {
54333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54334       };
54335     }
54336   }
54337
54338 }
54339
54340
54341 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Empty(void * jarg1) {
54342   unsigned int jresult ;
54343   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54344   bool result;
54345
54346   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54347   {
54348     try {
54349       result = (bool)Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
54350     } catch (std::out_of_range& e) {
54351       {
54352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54353       };
54354     } catch (std::exception& e) {
54355       {
54356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54357       };
54358     } catch (Dali::DaliException e) {
54359       {
54360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54361       };
54362     } catch (...) {
54363       {
54364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54365       };
54366     }
54367   }
54368
54369   jresult = result;
54370   return jresult;
54371 }
54372
54373
54374 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_GetConnectionCount(void * jarg1) {
54375   unsigned long jresult ;
54376   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54377   std::size_t result;
54378
54379   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54380   {
54381     try {
54382       result = Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
54383     } catch (std::out_of_range& e) {
54384       {
54385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54386       };
54387     } catch (std::exception& e) {
54388       {
54389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54390       };
54391     } catch (Dali::DaliException e) {
54392       {
54393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54394       };
54395     } catch (...) {
54396       {
54397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54398       };
54399     }
54400   }
54401
54402   jresult = (unsigned long)result;
54403   return jresult;
54404 }
54405
54406
54407 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Connect(void * jarg1, void * jarg2) {
54408   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54409   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
54410
54411   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54412   arg2 = (void (*)(Dali::RefObject const *))jarg2;
54413   {
54414     try {
54415       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(arg1,arg2);
54416     } catch (std::out_of_range& e) {
54417       {
54418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54419       };
54420     } catch (std::exception& e) {
54421       {
54422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54423       };
54424     } catch (Dali::DaliException e) {
54425       {
54426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54427       };
54428     } catch (...) {
54429       {
54430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54431       };
54432     }
54433   }
54434
54435 }
54436
54437
54438 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Disconnect(void * jarg1, void * jarg2) {
54439   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54440   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
54441
54442   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54443   arg2 = (void (*)(Dali::RefObject const *))jarg2;
54444   {
54445     try {
54446       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(arg1,arg2);
54447     } catch (std::out_of_range& e) {
54448       {
54449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54450       };
54451     } catch (std::exception& e) {
54452       {
54453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54454       };
54455     } catch (Dali::DaliException e) {
54456       {
54457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54458       };
54459     } catch (...) {
54460       {
54461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54462       };
54463     }
54464   }
54465
54466 }
54467
54468
54469 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Emit(void * jarg1, void * jarg2) {
54470   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54471   Dali::RefObject *arg2 = (Dali::RefObject *) 0 ;
54472
54473   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54474   arg2 = (Dali::RefObject *)jarg2;
54475   {
54476     try {
54477       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(arg1,(Dali::RefObject const *)arg2);
54478     } catch (std::out_of_range& e) {
54479       {
54480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54481       };
54482     } catch (std::exception& e) {
54483       {
54484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54485       };
54486     } catch (Dali::DaliException e) {
54487       {
54488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54489       };
54490     } catch (...) {
54491       {
54492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54493       };
54494     }
54495   }
54496
54497 }
54498
54499
54500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectDestroyedSignal() {
54501   void * jresult ;
54502   Dali::Signal< void (Dali::RefObject const *) > *result = 0 ;
54503
54504   {
54505     try {
54506       result = (Dali::Signal< void (Dali::RefObject const *) > *)new Dali::Signal< void (Dali::RefObject const *) >();
54507     } catch (std::out_of_range& e) {
54508       {
54509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54510       };
54511     } catch (std::exception& e) {
54512       {
54513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54514       };
54515     } catch (Dali::DaliException e) {
54516       {
54517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54518       };
54519     } catch (...) {
54520       {
54521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54522       };
54523     }
54524   }
54525
54526   jresult = (void *)result;
54527   return jresult;
54528 }
54529
54530
54531 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectDestroyedSignal(void * jarg1) {
54532   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54533
54534   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54535   {
54536     try {
54537       delete arg1;
54538     } catch (std::out_of_range& e) {
54539       {
54540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54541       };
54542     } catch (std::exception& e) {
54543       {
54544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54545       };
54546     } catch (Dali::DaliException e) {
54547       {
54548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54549       };
54550     } catch (...) {
54551       {
54552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54553       };
54554     }
54555   }
54556
54557 }
54558
54559
54560 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Empty(void * jarg1) {
54561   unsigned int jresult ;
54562   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54563   bool result;
54564
54565   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54566   {
54567     try {
54568       result = (bool)Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
54569     } catch (std::out_of_range& e) {
54570       {
54571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54572       };
54573     } catch (std::exception& e) {
54574       {
54575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54576       };
54577     } catch (Dali::DaliException e) {
54578       {
54579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54580       };
54581     } catch (...) {
54582       {
54583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54584       };
54585     }
54586   }
54587
54588   jresult = result;
54589   return jresult;
54590 }
54591
54592
54593 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_GetConnectionCount(void * jarg1) {
54594   unsigned long jresult ;
54595   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54596   std::size_t result;
54597
54598   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54599   {
54600     try {
54601       result = Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
54602     } catch (std::out_of_range& e) {
54603       {
54604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54605       };
54606     } catch (std::exception& e) {
54607       {
54608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54609       };
54610     } catch (Dali::DaliException e) {
54611       {
54612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54613       };
54614     } catch (...) {
54615       {
54616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54617       };
54618     }
54619   }
54620
54621   jresult = (unsigned long)result;
54622   return jresult;
54623 }
54624
54625
54626 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Connect(void * jarg1, void * jarg2) {
54627   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54628   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
54629
54630   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54631   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
54632   {
54633     try {
54634       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(arg1,arg2);
54635     } catch (std::out_of_range& e) {
54636       {
54637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54638       };
54639     } catch (std::exception& e) {
54640       {
54641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54642       };
54643     } catch (Dali::DaliException e) {
54644       {
54645         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54646       };
54647     } catch (...) {
54648       {
54649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54650       };
54651     }
54652   }
54653
54654 }
54655
54656
54657 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Disconnect(void * jarg1, void * jarg2) {
54658   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54659   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
54660
54661   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54662   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
54663   {
54664     try {
54665       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(arg1,arg2);
54666     } catch (std::out_of_range& e) {
54667       {
54668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54669       };
54670     } catch (std::exception& e) {
54671       {
54672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54673       };
54674     } catch (Dali::DaliException e) {
54675       {
54676         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54677       };
54678     } catch (...) {
54679       {
54680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54681       };
54682     }
54683   }
54684
54685 }
54686
54687
54688 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Emit(void * jarg1, void * jarg2) {
54689   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54690   Dali::PropertyNotification *arg2 = 0 ;
54691
54692   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54693   arg2 = (Dali::PropertyNotification *)jarg2;
54694   if (!arg2) {
54695     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification & type is null", 0);
54696     return ;
54697   }
54698   {
54699     try {
54700       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(arg1,*arg2);
54701     } catch (std::out_of_range& e) {
54702       {
54703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54704       };
54705     } catch (std::exception& e) {
54706       {
54707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54708       };
54709     } catch (Dali::DaliException e) {
54710       {
54711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54712       };
54713     } catch (...) {
54714       {
54715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54716       };
54717     }
54718   }
54719
54720 }
54721
54722
54723 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotifySignal() {
54724   void * jresult ;
54725   Dali::Signal< void (Dali::PropertyNotification &) > *result = 0 ;
54726
54727   {
54728     try {
54729       result = (Dali::Signal< void (Dali::PropertyNotification &) > *)new Dali::Signal< void (Dali::PropertyNotification &) >();
54730     } catch (std::out_of_range& e) {
54731       {
54732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54733       };
54734     } catch (std::exception& e) {
54735       {
54736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54737       };
54738     } catch (Dali::DaliException e) {
54739       {
54740         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54741       };
54742     } catch (...) {
54743       {
54744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54745       };
54746     }
54747   }
54748
54749   jresult = (void *)result;
54750   return jresult;
54751 }
54752
54753
54754 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotifySignal(void * jarg1) {
54755   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54756
54757   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54758   {
54759     try {
54760       delete arg1;
54761     } catch (std::out_of_range& e) {
54762       {
54763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54764       };
54765     } catch (std::exception& e) {
54766       {
54767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54768       };
54769     } catch (Dali::DaliException e) {
54770       {
54771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54772       };
54773     } catch (...) {
54774       {
54775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54776       };
54777     }
54778   }
54779
54780 }
54781
54782
54783 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ImageSignal_Empty(void * jarg1) {
54784   unsigned int jresult ;
54785   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54786   bool result;
54787
54788   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54789   {
54790     try {
54791       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty((Dali::Signal< void (Dali::Image) > const *)arg1);
54792     } catch (std::out_of_range& e) {
54793       {
54794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54795       };
54796     } catch (std::exception& e) {
54797       {
54798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54799       };
54800     } catch (Dali::DaliException e) {
54801       {
54802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54803       };
54804     } catch (...) {
54805       {
54806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54807       };
54808     }
54809   }
54810
54811   jresult = result;
54812   return jresult;
54813 }
54814
54815
54816 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ImageSignal_GetConnectionCount(void * jarg1) {
54817   unsigned long jresult ;
54818   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54819   std::size_t result;
54820
54821   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54822   {
54823     try {
54824       result = Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Image) > const *)arg1);
54825     } catch (std::out_of_range& e) {
54826       {
54827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54828       };
54829     } catch (std::exception& e) {
54830       {
54831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54832       };
54833     } catch (Dali::DaliException e) {
54834       {
54835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54836       };
54837     } catch (...) {
54838       {
54839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54840       };
54841     }
54842   }
54843
54844   jresult = (unsigned long)result;
54845   return jresult;
54846 }
54847
54848
54849 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Connect(void * jarg1, void * jarg2) {
54850   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54851   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
54852
54853   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54854   arg2 = (void (*)(Dali::Image))jarg2;
54855   {
54856     try {
54857       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(arg1,arg2);
54858     } catch (std::out_of_range& e) {
54859       {
54860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54861       };
54862     } catch (std::exception& e) {
54863       {
54864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54865       };
54866     } catch (Dali::DaliException e) {
54867       {
54868         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54869       };
54870     } catch (...) {
54871       {
54872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54873       };
54874     }
54875   }
54876
54877 }
54878
54879
54880 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Disconnect(void * jarg1, void * jarg2) {
54881   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54882   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
54883
54884   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54885   arg2 = (void (*)(Dali::Image))jarg2;
54886   {
54887     try {
54888       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(arg1,arg2);
54889     } catch (std::out_of_range& e) {
54890       {
54891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54892       };
54893     } catch (std::exception& e) {
54894       {
54895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54896       };
54897     } catch (Dali::DaliException e) {
54898       {
54899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54900       };
54901     } catch (...) {
54902       {
54903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54904       };
54905     }
54906   }
54907
54908 }
54909
54910
54911 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Emit(void * jarg1, void * jarg2) {
54912   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54913   Dali::Image arg2 ;
54914   Dali::Image *argp2 ;
54915
54916   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54917   argp2 = (Dali::Image *)jarg2;
54918   if (!argp2) {
54919     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
54920     return ;
54921   }
54922   arg2 = *argp2;
54923   {
54924     try {
54925       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(arg1,arg2);
54926     } catch (std::out_of_range& e) {
54927       {
54928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54929       };
54930     } catch (std::exception& e) {
54931       {
54932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54933       };
54934     } catch (Dali::DaliException e) {
54935       {
54936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54937       };
54938     } catch (...) {
54939       {
54940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54941       };
54942     }
54943   }
54944
54945 }
54946
54947
54948 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageSignal() {
54949   void * jresult ;
54950   Dali::Signal< void (Dali::Image) > *result = 0 ;
54951
54952   {
54953     try {
54954       result = (Dali::Signal< void (Dali::Image) > *)new Dali::Signal< void (Dali::Image) >();
54955     } catch (std::out_of_range& e) {
54956       {
54957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54958       };
54959     } catch (std::exception& e) {
54960       {
54961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54962       };
54963     } catch (Dali::DaliException e) {
54964       {
54965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54966       };
54967     } catch (...) {
54968       {
54969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54970       };
54971     }
54972   }
54973
54974   jresult = (void *)result;
54975   return jresult;
54976 }
54977
54978
54979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageSignal(void * jarg1) {
54980   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54981
54982   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54983   {
54984     try {
54985       delete arg1;
54986     } catch (std::out_of_range& e) {
54987       {
54988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54989       };
54990     } catch (std::exception& e) {
54991       {
54992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54993       };
54994     } catch (Dali::DaliException e) {
54995       {
54996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54997       };
54998     } catch (...) {
54999       {
55000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55001       };
55002     }
55003   }
55004
55005 }
55006
55007
55008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskSignal() {
55009   void * jresult ;
55010   Dali::Signal< void (Dali::RenderTask &) > *result = 0 ;
55011
55012   {
55013     try {
55014       result = (Dali::Signal< void (Dali::RenderTask &) > *)new Dali::Signal< void (Dali::RenderTask &) >();
55015     } catch (std::out_of_range& e) {
55016       {
55017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55018       };
55019     } catch (std::exception& e) {
55020       {
55021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55022       };
55023     } catch (Dali::DaliException e) {
55024       {
55025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55026       };
55027     } catch (...) {
55028       {
55029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55030       };
55031     }
55032   }
55033
55034   jresult = (void *)result;
55035   return jresult;
55036 }
55037
55038
55039 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskSignal(void * jarg1) {
55040   Dali::Signal< void (Dali::RenderTask &) > *arg1 = (Dali::Signal< void (Dali::RenderTask &) > *) 0 ;
55041
55042   arg1 = (Dali::Signal< void (Dali::RenderTask &) > *)jarg1;
55043   {
55044     try {
55045       delete arg1;
55046     } catch (std::out_of_range& e) {
55047       {
55048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55049       };
55050     } catch (std::exception& e) {
55051       {
55052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55053       };
55054     } catch (Dali::DaliException e) {
55055       {
55056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55057       };
55058     } catch (...) {
55059       {
55060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55061       };
55062     }
55063   }
55064
55065 }
55066
55067
55068 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Empty(void * jarg1) {
55069   unsigned int jresult ;
55070   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55071   bool result;
55072
55073   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55074   {
55075     try {
55076       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);
55077     } catch (std::out_of_range& e) {
55078       {
55079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55080       };
55081     } catch (std::exception& e) {
55082       {
55083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55084       };
55085     } catch (Dali::DaliException e) {
55086       {
55087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55088       };
55089     } catch (...) {
55090       {
55091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55092       };
55093     }
55094   }
55095
55096   jresult = result;
55097   return jresult;
55098 }
55099
55100
55101 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_GetConnectionCount(void * jarg1) {
55102   unsigned long jresult ;
55103   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55104   std::size_t result;
55105
55106   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55107   {
55108     try {
55109       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);
55110     } catch (std::out_of_range& e) {
55111       {
55112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55113       };
55114     } catch (std::exception& e) {
55115       {
55116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55117       };
55118     } catch (Dali::DaliException e) {
55119       {
55120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55121       };
55122     } catch (...) {
55123       {
55124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55125       };
55126     }
55127   }
55128
55129   jresult = (unsigned long)result;
55130   return jresult;
55131 }
55132
55133
55134 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
55135   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55136   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
55137
55138   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55139   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
55140   {
55141     try {
55142       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55143     } catch (std::out_of_range& e) {
55144       {
55145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55146       };
55147     } catch (std::exception& e) {
55148       {
55149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55150       };
55151     } catch (Dali::DaliException e) {
55152       {
55153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55154       };
55155     } catch (...) {
55156       {
55157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55158       };
55159     }
55160   }
55161
55162 }
55163
55164
55165 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
55166   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55167   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
55168
55169   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55170   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
55171   {
55172     try {
55173       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55174     } catch (std::out_of_range& e) {
55175       {
55176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55177       };
55178     } catch (std::exception& e) {
55179       {
55180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55181       };
55182     } catch (Dali::DaliException e) {
55183       {
55184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55185       };
55186     } catch (...) {
55187       {
55188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55189       };
55190     }
55191   }
55192
55193 }
55194
55195
55196 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55197   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55198   Dali::Actor arg2 ;
55199   Dali::LongPressGesture *arg3 = 0 ;
55200   Dali::Actor *argp2 ;
55201
55202   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55203   argp2 = (Dali::Actor *)jarg2;
55204   if (!argp2) {
55205     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55206     return ;
55207   }
55208   arg2 = *argp2;
55209   arg3 = (Dali::LongPressGesture *)jarg3;
55210   if (!arg3) {
55211     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
55212     return ;
55213   }
55214   {
55215     try {
55216       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::LongPressGesture const &)*arg3);
55217     } catch (std::out_of_range& e) {
55218       {
55219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55220       };
55221     } catch (std::exception& e) {
55222       {
55223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55224       };
55225     } catch (Dali::DaliException e) {
55226       {
55227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55228       };
55229     } catch (...) {
55230       {
55231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55232       };
55233     }
55234   }
55235
55236 }
55237
55238
55239 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetectedSignal() {
55240   void * jresult ;
55241   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *result = 0 ;
55242
55243   {
55244     try {
55245       result = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) >();
55246     } catch (std::out_of_range& e) {
55247       {
55248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55249       };
55250     } catch (std::exception& e) {
55251       {
55252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55253       };
55254     } catch (Dali::DaliException e) {
55255       {
55256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55257       };
55258     } catch (...) {
55259       {
55260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55261       };
55262     }
55263   }
55264
55265   jresult = (void *)result;
55266   return jresult;
55267 }
55268
55269
55270 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetectedSignal(void * jarg1) {
55271   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55272
55273   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55274   {
55275     try {
55276       delete arg1;
55277     } catch (std::out_of_range& e) {
55278       {
55279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55280       };
55281     } catch (std::exception& e) {
55282       {
55283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55284       };
55285     } catch (Dali::DaliException e) {
55286       {
55287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55288       };
55289     } catch (...) {
55290       {
55291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55292       };
55293     }
55294   }
55295
55296 }
55297
55298
55299 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Empty(void * jarg1) {
55300   unsigned int jresult ;
55301   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55302   bool result;
55303
55304   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55305   {
55306     try {
55307       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);
55308     } catch (std::out_of_range& e) {
55309       {
55310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55311       };
55312     } catch (std::exception& e) {
55313       {
55314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55315       };
55316     } catch (Dali::DaliException e) {
55317       {
55318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55319       };
55320     } catch (...) {
55321       {
55322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55323       };
55324     }
55325   }
55326
55327   jresult = result;
55328   return jresult;
55329 }
55330
55331
55332 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_GetConnectionCount(void * jarg1) {
55333   unsigned long jresult ;
55334   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55335   std::size_t result;
55336
55337   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55338   {
55339     try {
55340       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);
55341     } catch (std::out_of_range& e) {
55342       {
55343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55344       };
55345     } catch (std::exception& e) {
55346       {
55347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55348       };
55349     } catch (Dali::DaliException e) {
55350       {
55351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55352       };
55353     } catch (...) {
55354       {
55355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55356       };
55357     }
55358   }
55359
55360   jresult = (unsigned long)result;
55361   return jresult;
55362 }
55363
55364
55365 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Connect(void * jarg1, void * jarg2) {
55366   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55367   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
55368
55369   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55370   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
55371   {
55372     try {
55373       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55374     } catch (std::out_of_range& e) {
55375       {
55376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55377       };
55378     } catch (std::exception& e) {
55379       {
55380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55381       };
55382     } catch (Dali::DaliException e) {
55383       {
55384         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55385       };
55386     } catch (...) {
55387       {
55388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55389       };
55390     }
55391   }
55392
55393 }
55394
55395
55396 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Disconnect(void * jarg1, void * jarg2) {
55397   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55398   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
55399
55400   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55401   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
55402   {
55403     try {
55404       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55405     } catch (std::out_of_range& e) {
55406       {
55407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55408       };
55409     } catch (std::exception& e) {
55410       {
55411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55412       };
55413     } catch (Dali::DaliException e) {
55414       {
55415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55416       };
55417     } catch (...) {
55418       {
55419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55420       };
55421     }
55422   }
55423
55424 }
55425
55426
55427 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55428   unsigned int jresult ;
55429   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55430   Dali::Actor arg2 ;
55431   Dali::TouchData *arg3 = 0 ;
55432   Dali::Actor *argp2 ;
55433   bool result;
55434
55435   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55436   argp2 = (Dali::Actor *)jarg2;
55437   if (!argp2) {
55438     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55439     return 0;
55440   }
55441   arg2 = *argp2;
55442   arg3 = (Dali::TouchData *)jarg3;
55443   if (!arg3) {
55444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
55445     return 0;
55446   }
55447   {
55448     try {
55449       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TouchData const &)*arg3);
55450     } catch (std::out_of_range& e) {
55451       {
55452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55453       };
55454     } catch (std::exception& e) {
55455       {
55456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55457       };
55458     } catch (Dali::DaliException e) {
55459       {
55460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55461       };
55462     } catch (...) {
55463       {
55464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55465       };
55466     }
55467   }
55468
55469   jresult = result;
55470   return jresult;
55471 }
55472
55473
55474 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorTouchDataSignal() {
55475   void * jresult ;
55476   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *result = 0 ;
55477
55478   {
55479     try {
55480       result = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) >();
55481     } catch (std::out_of_range& e) {
55482       {
55483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55484       };
55485     } catch (std::exception& e) {
55486       {
55487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55488       };
55489     } catch (Dali::DaliException e) {
55490       {
55491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55492       };
55493     } catch (...) {
55494       {
55495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55496       };
55497     }
55498   }
55499
55500   jresult = (void *)result;
55501   return jresult;
55502 }
55503
55504
55505 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorTouchDataSignal(void * jarg1) {
55506   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55507
55508   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55509   {
55510     try {
55511       delete arg1;
55512     } catch (std::out_of_range& e) {
55513       {
55514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55515       };
55516     } catch (std::exception& e) {
55517       {
55518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55519       };
55520     } catch (Dali::DaliException e) {
55521       {
55522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55523       };
55524     } catch (...) {
55525       {
55526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55527       };
55528     }
55529   }
55530
55531 }
55532
55533
55534 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Empty(void * jarg1) {
55535   unsigned int jresult ;
55536   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55537   bool result;
55538
55539   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55540   {
55541     try {
55542       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);
55543     } catch (std::out_of_range& e) {
55544       {
55545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55546       };
55547     } catch (std::exception& e) {
55548       {
55549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55550       };
55551     } catch (Dali::DaliException e) {
55552       {
55553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55554       };
55555     } catch (...) {
55556       {
55557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55558       };
55559     }
55560   }
55561
55562   jresult = result;
55563   return jresult;
55564 }
55565
55566
55567 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorHoverSignal_GetConnectionCount(void * jarg1) {
55568   unsigned long jresult ;
55569   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55570   std::size_t result;
55571
55572   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55573   {
55574     try {
55575       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);
55576     } catch (std::out_of_range& e) {
55577       {
55578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55579       };
55580     } catch (std::exception& e) {
55581       {
55582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55583       };
55584     } catch (Dali::DaliException e) {
55585       {
55586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55587       };
55588     } catch (...) {
55589       {
55590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55591       };
55592     }
55593   }
55594
55595   jresult = (unsigned long)result;
55596   return jresult;
55597 }
55598
55599
55600 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Connect(void * jarg1, void * jarg2) {
55601   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55602   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
55603
55604   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55605   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
55606   {
55607     try {
55608       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55609     } catch (std::out_of_range& e) {
55610       {
55611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55612       };
55613     } catch (std::exception& e) {
55614       {
55615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55616       };
55617     } catch (Dali::DaliException e) {
55618       {
55619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55620       };
55621     } catch (...) {
55622       {
55623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55624       };
55625     }
55626   }
55627
55628 }
55629
55630
55631 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Disconnect(void * jarg1, void * jarg2) {
55632   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55633   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
55634
55635   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55636   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
55637   {
55638     try {
55639       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55640     } catch (std::out_of_range& e) {
55641       {
55642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55643       };
55644     } catch (std::exception& e) {
55645       {
55646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55647       };
55648     } catch (Dali::DaliException e) {
55649       {
55650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55651       };
55652     } catch (...) {
55653       {
55654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55655       };
55656     }
55657   }
55658
55659 }
55660
55661
55662 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55663   unsigned int jresult ;
55664   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55665   Dali::Actor arg2 ;
55666   Dali::HoverEvent *arg3 = 0 ;
55667   Dali::Actor *argp2 ;
55668   bool result;
55669
55670   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55671   argp2 = (Dali::Actor *)jarg2;
55672   if (!argp2) {
55673     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55674     return 0;
55675   }
55676   arg2 = *argp2;
55677   arg3 = (Dali::HoverEvent *)jarg3;
55678   if (!arg3) {
55679     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
55680     return 0;
55681   }
55682   {
55683     try {
55684       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::HoverEvent const &)*arg3);
55685     } catch (std::out_of_range& e) {
55686       {
55687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55688       };
55689     } catch (std::exception& e) {
55690       {
55691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55692       };
55693     } catch (Dali::DaliException e) {
55694       {
55695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55696       };
55697     } catch (...) {
55698       {
55699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55700       };
55701     }
55702   }
55703
55704   jresult = result;
55705   return jresult;
55706 }
55707
55708
55709 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorHoverSignal() {
55710   void * jresult ;
55711   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *result = 0 ;
55712
55713   {
55714     try {
55715       result = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) >();
55716     } catch (std::out_of_range& e) {
55717       {
55718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55719       };
55720     } catch (std::exception& e) {
55721       {
55722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55723       };
55724     } catch (Dali::DaliException e) {
55725       {
55726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55727       };
55728     } catch (...) {
55729       {
55730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55731       };
55732     }
55733   }
55734
55735   jresult = (void *)result;
55736   return jresult;
55737 }
55738
55739
55740 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorHoverSignal(void * jarg1) {
55741   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55742
55743   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55744   {
55745     try {
55746       delete arg1;
55747     } catch (std::out_of_range& e) {
55748       {
55749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55750       };
55751     } catch (std::exception& e) {
55752       {
55753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55754       };
55755     } catch (Dali::DaliException e) {
55756       {
55757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55758       };
55759     } catch (...) {
55760       {
55761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55762       };
55763     }
55764   }
55765
55766 }
55767
55768
55769 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Empty(void * jarg1) {
55770   unsigned int jresult ;
55771   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55772   bool result;
55773
55774   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55775   {
55776     try {
55777       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);
55778     } catch (std::out_of_range& e) {
55779       {
55780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55781       };
55782     } catch (std::exception& e) {
55783       {
55784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55785       };
55786     } catch (Dali::DaliException e) {
55787       {
55788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55789       };
55790     } catch (...) {
55791       {
55792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55793       };
55794     }
55795   }
55796
55797   jresult = result;
55798   return jresult;
55799 }
55800
55801
55802 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorWheelSignal_GetConnectionCount(void * jarg1) {
55803   unsigned long jresult ;
55804   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55805   std::size_t result;
55806
55807   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55808   {
55809     try {
55810       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);
55811     } catch (std::out_of_range& e) {
55812       {
55813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55814       };
55815     } catch (std::exception& e) {
55816       {
55817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55818       };
55819     } catch (Dali::DaliException e) {
55820       {
55821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55822       };
55823     } catch (...) {
55824       {
55825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55826       };
55827     }
55828   }
55829
55830   jresult = (unsigned long)result;
55831   return jresult;
55832 }
55833
55834
55835 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Connect(void * jarg1, void * jarg2) {
55836   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55837   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
55838
55839   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55840   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
55841   {
55842     try {
55843       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55844     } catch (std::out_of_range& e) {
55845       {
55846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55847       };
55848     } catch (std::exception& e) {
55849       {
55850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55851       };
55852     } catch (Dali::DaliException e) {
55853       {
55854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55855       };
55856     } catch (...) {
55857       {
55858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55859       };
55860     }
55861   }
55862
55863 }
55864
55865
55866 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Disconnect(void * jarg1, void * jarg2) {
55867   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55868   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
55869
55870   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55871   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
55872   {
55873     try {
55874       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55875     } catch (std::out_of_range& e) {
55876       {
55877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55878       };
55879     } catch (std::exception& e) {
55880       {
55881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55882       };
55883     } catch (Dali::DaliException e) {
55884       {
55885         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55886       };
55887     } catch (...) {
55888       {
55889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55890       };
55891     }
55892   }
55893
55894 }
55895
55896
55897 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55898   unsigned int jresult ;
55899   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55900   Dali::Actor arg2 ;
55901   Dali::WheelEvent *arg3 = 0 ;
55902   Dali::Actor *argp2 ;
55903   bool result;
55904
55905   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55906   argp2 = (Dali::Actor *)jarg2;
55907   if (!argp2) {
55908     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55909     return 0;
55910   }
55911   arg2 = *argp2;
55912   arg3 = (Dali::WheelEvent *)jarg3;
55913   if (!arg3) {
55914     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
55915     return 0;
55916   }
55917   {
55918     try {
55919       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::WheelEvent const &)*arg3);
55920     } catch (std::out_of_range& e) {
55921       {
55922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55923       };
55924     } catch (std::exception& e) {
55925       {
55926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55927       };
55928     } catch (Dali::DaliException e) {
55929       {
55930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55931       };
55932     } catch (...) {
55933       {
55934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55935       };
55936     }
55937   }
55938
55939   jresult = result;
55940   return jresult;
55941 }
55942
55943
55944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorWheelSignal() {
55945   void * jresult ;
55946   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *result = 0 ;
55947
55948   {
55949     try {
55950       result = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) >();
55951     } catch (std::out_of_range& e) {
55952       {
55953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55954       };
55955     } catch (std::exception& e) {
55956       {
55957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55958       };
55959     } catch (Dali::DaliException e) {
55960       {
55961         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55962       };
55963     } catch (...) {
55964       {
55965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55966       };
55967     }
55968   }
55969
55970   jresult = (void *)result;
55971   return jresult;
55972 }
55973
55974
55975 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorWheelSignal(void * jarg1) {
55976   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55977
55978   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55979   {
55980     try {
55981       delete arg1;
55982     } catch (std::out_of_range& e) {
55983       {
55984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55985       };
55986     } catch (std::exception& e) {
55987       {
55988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55989       };
55990     } catch (Dali::DaliException e) {
55991       {
55992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55993       };
55994     } catch (...) {
55995       {
55996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55997       };
55998     }
55999   }
56000
56001 }
56002
56003
56004 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorSignal_Empty(void * jarg1) {
56005   unsigned int jresult ;
56006   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56007   bool result;
56008
56009   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56010   {
56011     try {
56012       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor) > const *)arg1);
56013     } catch (std::out_of_range& e) {
56014       {
56015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56016       };
56017     } catch (std::exception& e) {
56018       {
56019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56020       };
56021     } catch (Dali::DaliException e) {
56022       {
56023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56024       };
56025     } catch (...) {
56026       {
56027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56028       };
56029     }
56030   }
56031
56032   jresult = result;
56033   return jresult;
56034 }
56035
56036
56037 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorSignal_GetConnectionCount(void * jarg1) {
56038   unsigned long jresult ;
56039   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56040   std::size_t result;
56041
56042   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56043   {
56044     try {
56045       result = Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor) > const *)arg1);
56046     } catch (std::out_of_range& e) {
56047       {
56048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56049       };
56050     } catch (std::exception& e) {
56051       {
56052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56053       };
56054     } catch (Dali::DaliException e) {
56055       {
56056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56057       };
56058     } catch (...) {
56059       {
56060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56061       };
56062     }
56063   }
56064
56065   jresult = (unsigned long)result;
56066   return jresult;
56067 }
56068
56069
56070 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Connect(void * jarg1, void * jarg2) {
56071   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56072   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
56073
56074   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56075   arg2 = (void (*)(Dali::Actor))jarg2;
56076   {
56077     try {
56078       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(arg1,arg2);
56079     } catch (std::out_of_range& e) {
56080       {
56081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56082       };
56083     } catch (std::exception& e) {
56084       {
56085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56086       };
56087     } catch (Dali::DaliException e) {
56088       {
56089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56090       };
56091     } catch (...) {
56092       {
56093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56094       };
56095     }
56096   }
56097
56098 }
56099
56100
56101 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Disconnect(void * jarg1, void * jarg2) {
56102   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56103   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
56104
56105   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56106   arg2 = (void (*)(Dali::Actor))jarg2;
56107   {
56108     try {
56109       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
56110     } catch (std::out_of_range& e) {
56111       {
56112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56113       };
56114     } catch (std::exception& e) {
56115       {
56116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56117       };
56118     } catch (Dali::DaliException e) {
56119       {
56120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56121       };
56122     } catch (...) {
56123       {
56124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56125       };
56126     }
56127   }
56128
56129 }
56130
56131
56132 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Emit(void * jarg1, void * jarg2) {
56133   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56134   Dali::Actor arg2 ;
56135   Dali::Actor *argp2 ;
56136
56137   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56138   argp2 = (Dali::Actor *)jarg2;
56139   if (!argp2) {
56140     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
56141     return ;
56142   }
56143   arg2 = *argp2;
56144   {
56145     try {
56146       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(arg1,arg2);
56147     } catch (std::out_of_range& e) {
56148       {
56149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56150       };
56151     } catch (std::exception& e) {
56152       {
56153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56154       };
56155     } catch (Dali::DaliException e) {
56156       {
56157         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56158       };
56159     } catch (...) {
56160       {
56161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56162       };
56163     }
56164   }
56165
56166 }
56167
56168
56169 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorSignal() {
56170   void * jresult ;
56171   Dali::Signal< void (Dali::Actor) > *result = 0 ;
56172
56173   {
56174     try {
56175       result = (Dali::Signal< void (Dali::Actor) > *)new Dali::Signal< void (Dali::Actor) >();
56176     } catch (std::out_of_range& e) {
56177       {
56178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56179       };
56180     } catch (std::exception& e) {
56181       {
56182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56183       };
56184     } catch (Dali::DaliException e) {
56185       {
56186         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56187       };
56188     } catch (...) {
56189       {
56190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56191       };
56192     }
56193   }
56194
56195   jresult = (void *)result;
56196   return jresult;
56197 }
56198
56199
56200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorSignal(void * jarg1) {
56201   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56202
56203   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56204   {
56205     try {
56206       delete arg1;
56207     } catch (std::out_of_range& e) {
56208       {
56209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56210       };
56211     } catch (std::exception& e) {
56212       {
56213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56214       };
56215     } catch (Dali::DaliException e) {
56216       {
56217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56218       };
56219     } catch (...) {
56220       {
56221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56222       };
56223     }
56224   }
56225
56226 }
56227
56228
56229 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyEventSignal_Empty(void * jarg1) {
56230   unsigned int jresult ;
56231   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56232   bool result;
56233
56234   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56235   {
56236     try {
56237       result = (bool)Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
56238     } catch (std::out_of_range& e) {
56239       {
56240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56241       };
56242     } catch (std::exception& e) {
56243       {
56244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56245       };
56246     } catch (Dali::DaliException e) {
56247       {
56248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56249       };
56250     } catch (...) {
56251       {
56252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56253       };
56254     }
56255   }
56256
56257   jresult = result;
56258   return jresult;
56259 }
56260
56261
56262 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyEventSignal_GetConnectionCount(void * jarg1) {
56263   unsigned long jresult ;
56264   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56265   std::size_t result;
56266
56267   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56268   {
56269     try {
56270       result = Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
56271     } catch (std::out_of_range& e) {
56272       {
56273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56274       };
56275     } catch (std::exception& e) {
56276       {
56277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56278       };
56279     } catch (Dali::DaliException e) {
56280       {
56281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56282       };
56283     } catch (...) {
56284       {
56285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56286       };
56287     }
56288   }
56289
56290   jresult = (unsigned long)result;
56291   return jresult;
56292 }
56293
56294
56295 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Connect(void * jarg1, void * jarg2) {
56296   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56297   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
56298
56299   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56300   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
56301   {
56302     try {
56303       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
56304     } catch (std::out_of_range& e) {
56305       {
56306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56307       };
56308     } catch (std::exception& e) {
56309       {
56310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56311       };
56312     } catch (Dali::DaliException e) {
56313       {
56314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56315       };
56316     } catch (...) {
56317       {
56318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56319       };
56320     }
56321   }
56322
56323 }
56324
56325
56326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Disconnect(void * jarg1, void * jarg2) {
56327   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56328   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
56329
56330   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56331   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
56332   {
56333     try {
56334       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
56335     } catch (std::out_of_range& e) {
56336       {
56337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56338       };
56339     } catch (std::exception& e) {
56340       {
56341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56342       };
56343     } catch (Dali::DaliException e) {
56344       {
56345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56346       };
56347     } catch (...) {
56348       {
56349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56350       };
56351     }
56352   }
56353
56354 }
56355
56356
56357 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Emit(void * jarg1, void * jarg2) {
56358   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56359   Dali::KeyEvent *arg2 = 0 ;
56360
56361   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56362   arg2 = (Dali::KeyEvent *)jarg2;
56363   if (!arg2) {
56364     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
56365     return ;
56366   }
56367   {
56368     try {
56369       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::KeyEvent const &)*arg2);
56370     } catch (std::out_of_range& e) {
56371       {
56372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56373       };
56374     } catch (std::exception& e) {
56375       {
56376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56377       };
56378     } catch (Dali::DaliException e) {
56379       {
56380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56381       };
56382     } catch (...) {
56383       {
56384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56385       };
56386     }
56387   }
56388
56389 }
56390
56391
56392 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyEventSignal() {
56393   void * jresult ;
56394   Dali::Signal< void (Dali::KeyEvent const &) > *result = 0 ;
56395
56396   {
56397     try {
56398       result = (Dali::Signal< void (Dali::KeyEvent const &) > *)new Dali::Signal< void (Dali::KeyEvent const &) >();
56399     } catch (std::out_of_range& e) {
56400       {
56401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56402       };
56403     } catch (std::exception& e) {
56404       {
56405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56406       };
56407     } catch (Dali::DaliException e) {
56408       {
56409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56410       };
56411     } catch (...) {
56412       {
56413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56414       };
56415     }
56416   }
56417
56418   jresult = (void *)result;
56419   return jresult;
56420 }
56421
56422
56423 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyEventSignal(void * jarg1) {
56424   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56425
56426   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56427   {
56428     try {
56429       delete arg1;
56430     } catch (std::out_of_range& e) {
56431       {
56432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56433       };
56434     } catch (std::exception& e) {
56435       {
56436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56437       };
56438     } catch (Dali::DaliException e) {
56439       {
56440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56441       };
56442     } catch (...) {
56443       {
56444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56445       };
56446     }
56447   }
56448
56449 }
56450
56451
56452 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TouchSignal_Empty(void * jarg1) {
56453   unsigned int jresult ;
56454   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56455   bool result;
56456
56457   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56458   {
56459     try {
56460       result = (bool)Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
56461     } catch (std::out_of_range& e) {
56462       {
56463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56464       };
56465     } catch (std::exception& e) {
56466       {
56467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56468       };
56469     } catch (Dali::DaliException e) {
56470       {
56471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56472       };
56473     } catch (...) {
56474       {
56475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56476       };
56477     }
56478   }
56479
56480   jresult = result;
56481   return jresult;
56482 }
56483
56484
56485 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchSignal_GetConnectionCount(void * jarg1) {
56486   unsigned long jresult ;
56487   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56488   std::size_t result;
56489
56490   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56491   {
56492     try {
56493       result = Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
56494     } catch (std::out_of_range& e) {
56495       {
56496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56497       };
56498     } catch (std::exception& e) {
56499       {
56500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56501       };
56502     } catch (Dali::DaliException e) {
56503       {
56504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56505       };
56506     } catch (...) {
56507       {
56508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56509       };
56510     }
56511   }
56512
56513   jresult = (unsigned long)result;
56514   return jresult;
56515 }
56516
56517
56518 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Connect(void * jarg1, void * jarg2) {
56519   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56520   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
56521
56522   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56523   arg2 = (void (*)(Dali::TouchData const &))jarg2;
56524   {
56525     try {
56526       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
56527     } catch (std::out_of_range& e) {
56528       {
56529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56530       };
56531     } catch (std::exception& e) {
56532       {
56533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56534       };
56535     } catch (Dali::DaliException e) {
56536       {
56537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56538       };
56539     } catch (...) {
56540       {
56541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56542       };
56543     }
56544   }
56545
56546 }
56547
56548
56549 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Disconnect(void * jarg1, void * jarg2) {
56550   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56551   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
56552
56553   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56554   arg2 = (void (*)(Dali::TouchData const &))jarg2;
56555   {
56556     try {
56557       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
56558     } catch (std::out_of_range& e) {
56559       {
56560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56561       };
56562     } catch (std::exception& e) {
56563       {
56564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56565       };
56566     } catch (Dali::DaliException e) {
56567       {
56568         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56569       };
56570     } catch (...) {
56571       {
56572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56573       };
56574     }
56575   }
56576
56577 }
56578
56579
56580 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Emit(void * jarg1, void * jarg2) {
56581   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56582   Dali::TouchData *arg2 = 0 ;
56583
56584   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56585   arg2 = (Dali::TouchData *)jarg2;
56586   if (!arg2) {
56587     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
56588     return ;
56589   }
56590   {
56591     try {
56592       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,(Dali::TouchData const &)*arg2);
56593     } catch (std::out_of_range& e) {
56594       {
56595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56596       };
56597     } catch (std::exception& e) {
56598       {
56599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56600       };
56601     } catch (Dali::DaliException e) {
56602       {
56603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56604       };
56605     } catch (...) {
56606       {
56607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56608       };
56609     }
56610   }
56611
56612 }
56613
56614
56615 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchSignal() {
56616   void * jresult ;
56617   Dali::Signal< void (Dali::TouchData const &) > *result = 0 ;
56618
56619   {
56620     try {
56621       result = (Dali::Signal< void (Dali::TouchData const &) > *)new Dali::Signal< void (Dali::TouchData const &) >();
56622     } catch (std::out_of_range& e) {
56623       {
56624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56625       };
56626     } catch (std::exception& e) {
56627       {
56628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56629       };
56630     } catch (Dali::DaliException e) {
56631       {
56632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56633       };
56634     } catch (...) {
56635       {
56636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56637       };
56638     }
56639   }
56640
56641   jresult = (void *)result;
56642   return jresult;
56643 }
56644
56645
56646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchSignal(void * jarg1) {
56647   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56648
56649   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56650   {
56651     try {
56652       delete arg1;
56653     } catch (std::out_of_range& e) {
56654       {
56655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56656       };
56657     } catch (std::exception& e) {
56658       {
56659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56660       };
56661     } catch (Dali::DaliException e) {
56662       {
56663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56664       };
56665     } catch (...) {
56666       {
56667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56668       };
56669     }
56670   }
56671
56672 }
56673
56674
56675 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StageWheelSignal_Empty(void * jarg1) {
56676   unsigned int jresult ;
56677   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56678   bool result;
56679
56680   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56681   {
56682     try {
56683       result = (bool)Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
56684     } catch (std::out_of_range& e) {
56685       {
56686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56687       };
56688     } catch (std::exception& e) {
56689       {
56690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56691       };
56692     } catch (Dali::DaliException e) {
56693       {
56694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56695       };
56696     } catch (...) {
56697       {
56698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56699       };
56700     }
56701   }
56702
56703   jresult = result;
56704   return jresult;
56705 }
56706
56707
56708 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StageWheelSignal_GetConnectionCount(void * jarg1) {
56709   unsigned long jresult ;
56710   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56711   std::size_t result;
56712
56713   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56714   {
56715     try {
56716       result = Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
56717     } catch (std::out_of_range& e) {
56718       {
56719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56720       };
56721     } catch (std::exception& e) {
56722       {
56723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56724       };
56725     } catch (Dali::DaliException e) {
56726       {
56727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56728       };
56729     } catch (...) {
56730       {
56731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56732       };
56733     }
56734   }
56735
56736   jresult = (unsigned long)result;
56737   return jresult;
56738 }
56739
56740
56741 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Connect(void * jarg1, void * jarg2) {
56742   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56743   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
56744
56745   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56746   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
56747   {
56748     try {
56749       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
56750     } catch (std::out_of_range& e) {
56751       {
56752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56753       };
56754     } catch (std::exception& e) {
56755       {
56756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56757       };
56758     } catch (Dali::DaliException e) {
56759       {
56760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56761       };
56762     } catch (...) {
56763       {
56764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56765       };
56766     }
56767   }
56768
56769 }
56770
56771
56772 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Disconnect(void * jarg1, void * jarg2) {
56773   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56774   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
56775
56776   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56777   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
56778   {
56779     try {
56780       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
56781     } catch (std::out_of_range& e) {
56782       {
56783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56784       };
56785     } catch (std::exception& e) {
56786       {
56787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56788       };
56789     } catch (Dali::DaliException e) {
56790       {
56791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56792       };
56793     } catch (...) {
56794       {
56795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56796       };
56797     }
56798   }
56799
56800 }
56801
56802
56803 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Emit(void * jarg1, void * jarg2) {
56804   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56805   Dali::WheelEvent *arg2 = 0 ;
56806
56807   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56808   arg2 = (Dali::WheelEvent *)jarg2;
56809   if (!arg2) {
56810     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
56811     return ;
56812   }
56813   {
56814     try {
56815       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::WheelEvent const &)*arg2);
56816     } catch (std::out_of_range& e) {
56817       {
56818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56819       };
56820     } catch (std::exception& e) {
56821       {
56822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56823       };
56824     } catch (Dali::DaliException e) {
56825       {
56826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56827       };
56828     } catch (...) {
56829       {
56830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56831       };
56832     }
56833   }
56834
56835 }
56836
56837
56838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StageWheelSignal() {
56839   void * jresult ;
56840   Dali::Signal< void (Dali::WheelEvent const &) > *result = 0 ;
56841
56842   {
56843     try {
56844       result = (Dali::Signal< void (Dali::WheelEvent const &) > *)new Dali::Signal< void (Dali::WheelEvent const &) >();
56845     } catch (std::out_of_range& e) {
56846       {
56847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56848       };
56849     } catch (std::exception& e) {
56850       {
56851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56852       };
56853     } catch (Dali::DaliException e) {
56854       {
56855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56856       };
56857     } catch (...) {
56858       {
56859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56860       };
56861     }
56862   }
56863
56864   jresult = (void *)result;
56865   return jresult;
56866 }
56867
56868
56869 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StageWheelSignal(void * jarg1) {
56870   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56871
56872   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56873   {
56874     try {
56875       delete arg1;
56876     } catch (std::out_of_range& e) {
56877       {
56878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56879       };
56880     } catch (std::exception& e) {
56881       {
56882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56883       };
56884     } catch (Dali::DaliException e) {
56885       {
56886         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56887       };
56888     } catch (...) {
56889       {
56890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56891       };
56892     }
56893   }
56894
56895 }
56896
56897
56898 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_0() {
56899   void * jresult ;
56900   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
56901
56902   {
56903     try {
56904       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >();
56905     } catch (std::out_of_range& e) {
56906       {
56907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56908       };
56909     } catch (std::exception& e) {
56910       {
56911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56912       };
56913     } catch (Dali::DaliException e) {
56914       {
56915         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56916       };
56917     } catch (...) {
56918       {
56919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56920       };
56921     }
56922   }
56923
56924   jresult = (void *)result;
56925   return jresult;
56926 }
56927
56928
56929 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_1(void * jarg1, void * jarg2) {
56930   void * jresult ;
56931   Dali::Radian arg1 ;
56932   Dali::Radian arg2 ;
56933   Dali::Radian *argp1 ;
56934   Dali::Radian *argp2 ;
56935   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
56936
56937   argp1 = (Dali::Radian *)jarg1;
56938   if (!argp1) {
56939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
56940     return 0;
56941   }
56942   arg1 = *argp1;
56943   argp2 = (Dali::Radian *)jarg2;
56944   if (!argp2) {
56945     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
56946     return 0;
56947   }
56948   arg2 = *argp2;
56949   {
56950     try {
56951       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >(arg1,arg2);
56952     } catch (std::out_of_range& e) {
56953       {
56954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56955       };
56956     } catch (std::exception& e) {
56957       {
56958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56959       };
56960     } catch (Dali::DaliException e) {
56961       {
56962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56963       };
56964     } catch (...) {
56965       {
56966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56967       };
56968     }
56969   }
56970
56971   jresult = (void *)result;
56972   return jresult;
56973 }
56974
56975
56976 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_2(void * jarg1) {
56977   void * jresult ;
56978   std::pair< Dali::Radian,Dali::Radian > *arg1 = 0 ;
56979   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
56980
56981   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
56982   if (!arg1) {
56983     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< Dali::Radian,Dali::Radian > const & type is null", 0);
56984     return 0;
56985   }
56986   {
56987     try {
56988       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >((std::pair< Dali::Radian,Dali::Radian > const &)*arg1);
56989     } catch (std::out_of_range& e) {
56990       {
56991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56992       };
56993     } catch (std::exception& e) {
56994       {
56995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56996       };
56997     } catch (Dali::DaliException e) {
56998       {
56999         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57000       };
57001     } catch (...) {
57002       {
57003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57004       };
57005     }
57006   }
57007
57008   jresult = (void *)result;
57009   return jresult;
57010 }
57011
57012
57013 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_set(void * jarg1, void * jarg2) {
57014   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
57015   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
57016
57017   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57018   arg2 = (Dali::Radian *)jarg2;
57019   if (arg1) (arg1)->first = *arg2;
57020 }
57021
57022
57023 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_get(void * jarg1) {
57024   void * jresult ;
57025   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
57026   Dali::Radian *result = 0 ;
57027
57028   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57029   result = (Dali::Radian *)& ((arg1)->first);
57030   jresult = (void *)result;
57031   return jresult;
57032 }
57033
57034
57035 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_set(void * jarg1, void * jarg2) {
57036   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
57037   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
57038
57039   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57040   arg2 = (Dali::Radian *)jarg2;
57041   if (arg1) (arg1)->second = *arg2;
57042 }
57043
57044
57045 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_get(void * jarg1) {
57046   void * jresult ;
57047   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
57048   Dali::Radian *result = 0 ;
57049
57050   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57051   result = (Dali::Radian *)& ((arg1)->second);
57052   jresult = (void *)result;
57053   return jresult;
57054 }
57055
57056
57057 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleThresholdPair(void * jarg1) {
57058   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
57059
57060   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57061   {
57062     try {
57063       delete arg1;
57064     } catch (std::out_of_range& e) {
57065       {
57066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57067       };
57068     } catch (std::exception& e) {
57069       {
57070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57071       };
57072     } catch (Dali::DaliException e) {
57073       {
57074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57075       };
57076     } catch (...) {
57077       {
57078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57079       };
57080     }
57081   }
57082
57083 }
57084
57085
57086 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Empty(void * jarg1) {
57087   unsigned int jresult ;
57088   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57089   bool result;
57090
57091   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57092   {
57093     try {
57094       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);
57095     } catch (std::out_of_range& e) {
57096       {
57097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57098       };
57099     } catch (std::exception& e) {
57100       {
57101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57102       };
57103     } catch (Dali::DaliException e) {
57104       {
57105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57106       };
57107     } catch (...) {
57108       {
57109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57110       };
57111     }
57112   }
57113
57114   jresult = result;
57115   return jresult;
57116 }
57117
57118
57119 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_GetConnectionCount(void * jarg1) {
57120   unsigned long jresult ;
57121   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57122   std::size_t result;
57123
57124   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57125   {
57126     try {
57127       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);
57128     } catch (std::out_of_range& e) {
57129       {
57130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57131       };
57132     } catch (std::exception& e) {
57133       {
57134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57135       };
57136     } catch (Dali::DaliException e) {
57137       {
57138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57139       };
57140     } catch (...) {
57141       {
57142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57143       };
57144     }
57145   }
57146
57147   jresult = (unsigned long)result;
57148   return jresult;
57149 }
57150
57151
57152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
57153   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57154   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
57155
57156   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57157   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
57158   {
57159     try {
57160       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
57161     } catch (std::out_of_range& e) {
57162       {
57163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57164       };
57165     } catch (std::exception& e) {
57166       {
57167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57168       };
57169     } catch (Dali::DaliException e) {
57170       {
57171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57172       };
57173     } catch (...) {
57174       {
57175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57176       };
57177     }
57178   }
57179
57180 }
57181
57182
57183 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
57184   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57185   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
57186
57187   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57188   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
57189   {
57190     try {
57191       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
57192     } catch (std::out_of_range& e) {
57193       {
57194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57195       };
57196     } catch (std::exception& e) {
57197       {
57198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57199       };
57200     } catch (Dali::DaliException e) {
57201       {
57202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57203       };
57204     } catch (...) {
57205       {
57206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57207       };
57208     }
57209   }
57210
57211 }
57212
57213
57214 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
57215   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57216   Dali::Actor arg2 ;
57217   Dali::PanGesture *arg3 = 0 ;
57218   Dali::Actor *argp2 ;
57219
57220   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57221   argp2 = (Dali::Actor *)jarg2;
57222   if (!argp2) {
57223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57224     return ;
57225   }
57226   arg2 = *argp2;
57227   arg3 = (Dali::PanGesture *)jarg3;
57228   if (!arg3) {
57229     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
57230     return ;
57231   }
57232   {
57233     try {
57234       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PanGesture const &)*arg3);
57235     } catch (std::out_of_range& e) {
57236       {
57237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57238       };
57239     } catch (std::exception& e) {
57240       {
57241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57242       };
57243     } catch (Dali::DaliException e) {
57244       {
57245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57246       };
57247     } catch (...) {
57248       {
57249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57250       };
57251     }
57252   }
57253
57254 }
57255
57256
57257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetectedSignal() {
57258   void * jresult ;
57259   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *result = 0 ;
57260
57261   {
57262     try {
57263       result = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) >();
57264     } catch (std::out_of_range& e) {
57265       {
57266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57267       };
57268     } catch (std::exception& e) {
57269       {
57270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57271       };
57272     } catch (Dali::DaliException e) {
57273       {
57274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57275       };
57276     } catch (...) {
57277       {
57278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57279       };
57280     }
57281   }
57282
57283   jresult = (void *)result;
57284   return jresult;
57285 }
57286
57287
57288 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetectedSignal(void * jarg1) {
57289   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57290
57291   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57292   {
57293     try {
57294       delete arg1;
57295     } catch (std::out_of_range& e) {
57296       {
57297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57298       };
57299     } catch (std::exception& e) {
57300       {
57301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57302       };
57303     } catch (Dali::DaliException e) {
57304       {
57305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57306       };
57307     } catch (...) {
57308       {
57309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57310       };
57311     }
57312   }
57313
57314 }
57315
57316
57317 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Empty(void * jarg1) {
57318   unsigned int jresult ;
57319   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57320   bool result;
57321
57322   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57323   {
57324     try {
57325       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);
57326     } catch (std::out_of_range& e) {
57327       {
57328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57329       };
57330     } catch (std::exception& e) {
57331       {
57332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57333       };
57334     } catch (Dali::DaliException e) {
57335       {
57336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57337       };
57338     } catch (...) {
57339       {
57340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57341       };
57342     }
57343   }
57344
57345   jresult = result;
57346   return jresult;
57347 }
57348
57349
57350 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_GetConnectionCount(void * jarg1) {
57351   unsigned long jresult ;
57352   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57353   std::size_t result;
57354
57355   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57356   {
57357     try {
57358       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);
57359     } catch (std::out_of_range& e) {
57360       {
57361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57362       };
57363     } catch (std::exception& e) {
57364       {
57365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57366       };
57367     } catch (Dali::DaliException e) {
57368       {
57369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57370       };
57371     } catch (...) {
57372       {
57373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57374       };
57375     }
57376   }
57377
57378   jresult = (unsigned long)result;
57379   return jresult;
57380 }
57381
57382
57383 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
57384   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57385   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
57386
57387   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57388   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
57389   {
57390     try {
57391       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
57392     } catch (std::out_of_range& e) {
57393       {
57394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57395       };
57396     } catch (std::exception& e) {
57397       {
57398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57399       };
57400     } catch (Dali::DaliException e) {
57401       {
57402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57403       };
57404     } catch (...) {
57405       {
57406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57407       };
57408     }
57409   }
57410
57411 }
57412
57413
57414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
57415   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57416   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
57417
57418   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57419   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
57420   {
57421     try {
57422       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
57423     } catch (std::out_of_range& e) {
57424       {
57425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57426       };
57427     } catch (std::exception& e) {
57428       {
57429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57430       };
57431     } catch (Dali::DaliException e) {
57432       {
57433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57434       };
57435     } catch (...) {
57436       {
57437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57438       };
57439     }
57440   }
57441
57442 }
57443
57444
57445 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
57446   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57447   Dali::Actor arg2 ;
57448   Dali::PinchGesture *arg3 = 0 ;
57449   Dali::Actor *argp2 ;
57450
57451   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57452   argp2 = (Dali::Actor *)jarg2;
57453   if (!argp2) {
57454     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57455     return ;
57456   }
57457   arg2 = *argp2;
57458   arg3 = (Dali::PinchGesture *)jarg3;
57459   if (!arg3) {
57460     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
57461     return ;
57462   }
57463   {
57464     try {
57465       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PinchGesture const &)*arg3);
57466     } catch (std::out_of_range& e) {
57467       {
57468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57469       };
57470     } catch (std::exception& e) {
57471       {
57472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57473       };
57474     } catch (Dali::DaliException e) {
57475       {
57476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57477       };
57478     } catch (...) {
57479       {
57480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57481       };
57482     }
57483   }
57484
57485 }
57486
57487
57488 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetectedSignal() {
57489   void * jresult ;
57490   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *result = 0 ;
57491
57492   {
57493     try {
57494       result = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) >();
57495     } catch (std::out_of_range& e) {
57496       {
57497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57498       };
57499     } catch (std::exception& e) {
57500       {
57501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57502       };
57503     } catch (Dali::DaliException e) {
57504       {
57505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57506       };
57507     } catch (...) {
57508       {
57509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57510       };
57511     }
57512   }
57513
57514   jresult = (void *)result;
57515   return jresult;
57516 }
57517
57518
57519 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetectedSignal(void * jarg1) {
57520   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57521
57522   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57523   {
57524     try {
57525       delete arg1;
57526     } catch (std::out_of_range& e) {
57527       {
57528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57529       };
57530     } catch (std::exception& e) {
57531       {
57532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57533       };
57534     } catch (Dali::DaliException e) {
57535       {
57536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57537       };
57538     } catch (...) {
57539       {
57540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57541       };
57542     }
57543   }
57544
57545 }
57546
57547
57548 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Empty(void * jarg1) {
57549   unsigned int jresult ;
57550   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57551   bool result;
57552
57553   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57554   {
57555     try {
57556       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);
57557     } catch (std::out_of_range& e) {
57558       {
57559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57560       };
57561     } catch (std::exception& e) {
57562       {
57563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57564       };
57565     } catch (Dali::DaliException e) {
57566       {
57567         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57568       };
57569     } catch (...) {
57570       {
57571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57572       };
57573     }
57574   }
57575
57576   jresult = result;
57577   return jresult;
57578 }
57579
57580
57581 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_GetConnectionCount(void * jarg1) {
57582   unsigned long jresult ;
57583   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57584   std::size_t result;
57585
57586   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57587   {
57588     try {
57589       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);
57590     } catch (std::out_of_range& e) {
57591       {
57592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57593       };
57594     } catch (std::exception& e) {
57595       {
57596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57597       };
57598     } catch (Dali::DaliException e) {
57599       {
57600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57601       };
57602     } catch (...) {
57603       {
57604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57605       };
57606     }
57607   }
57608
57609   jresult = (unsigned long)result;
57610   return jresult;
57611 }
57612
57613
57614 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
57615   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57616   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
57617
57618   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57619   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
57620   {
57621     try {
57622       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
57623     } catch (std::out_of_range& e) {
57624       {
57625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57626       };
57627     } catch (std::exception& e) {
57628       {
57629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57630       };
57631     } catch (Dali::DaliException e) {
57632       {
57633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57634       };
57635     } catch (...) {
57636       {
57637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57638       };
57639     }
57640   }
57641
57642 }
57643
57644
57645 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
57646   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57647   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
57648
57649   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57650   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
57651   {
57652     try {
57653       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
57654     } catch (std::out_of_range& e) {
57655       {
57656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57657       };
57658     } catch (std::exception& e) {
57659       {
57660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57661       };
57662     } catch (Dali::DaliException e) {
57663       {
57664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57665       };
57666     } catch (...) {
57667       {
57668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57669       };
57670     }
57671   }
57672
57673 }
57674
57675
57676 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
57677   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57678   Dali::Actor arg2 ;
57679   Dali::TapGesture *arg3 = 0 ;
57680   Dali::Actor *argp2 ;
57681
57682   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57683   argp2 = (Dali::Actor *)jarg2;
57684   if (!argp2) {
57685     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57686     return ;
57687   }
57688   arg2 = *argp2;
57689   arg3 = (Dali::TapGesture *)jarg3;
57690   if (!arg3) {
57691     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
57692     return ;
57693   }
57694   {
57695     try {
57696       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TapGesture const &)*arg3);
57697     } catch (std::out_of_range& e) {
57698       {
57699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57700       };
57701     } catch (std::exception& e) {
57702       {
57703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57704       };
57705     } catch (Dali::DaliException e) {
57706       {
57707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57708       };
57709     } catch (...) {
57710       {
57711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57712       };
57713     }
57714   }
57715
57716 }
57717
57718
57719 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetectedSignal() {
57720   void * jresult ;
57721   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *result = 0 ;
57722
57723   {
57724     try {
57725       result = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) >();
57726     } catch (std::out_of_range& e) {
57727       {
57728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57729       };
57730     } catch (std::exception& e) {
57731       {
57732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57733       };
57734     } catch (Dali::DaliException e) {
57735       {
57736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57737       };
57738     } catch (...) {
57739       {
57740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57741       };
57742     }
57743   }
57744
57745   jresult = (void *)result;
57746   return jresult;
57747 }
57748
57749
57750 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetectedSignal(void * jarg1) {
57751   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57752
57753   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57754   {
57755     try {
57756       delete arg1;
57757     } catch (std::out_of_range& e) {
57758       {
57759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57760       };
57761     } catch (std::exception& e) {
57762       {
57763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57764       };
57765     } catch (Dali::DaliException e) {
57766       {
57767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57768       };
57769     } catch (...) {
57770       {
57771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57772       };
57773     }
57774   }
57775
57776 }
57777
57778 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Empty(void * jarg1) {
57779   unsigned int jresult ;
57780   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57781   bool result;
57782
57783   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57784   {
57785     try {
57786       result = (bool)Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
57787     } catch (std::out_of_range& e) {
57788       {
57789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57790       };
57791     } catch (std::exception& e) {
57792       {
57793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57794       };
57795     } catch (Dali::DaliException e) {
57796       {
57797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57798       };
57799     } catch (...) {
57800       {
57801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57802       };
57803     }
57804   }
57805
57806   jresult = result;
57807   return jresult;
57808 }
57809
57810
57811 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ResourceImageSignal_GetConnectionCount(void * jarg1) {
57812   unsigned long jresult ;
57813   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57814   std::size_t result;
57815
57816   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57817   {
57818     try {
57819       result = Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
57820     } catch (std::out_of_range& e) {
57821       {
57822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57823       };
57824     } catch (std::exception& e) {
57825       {
57826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57827       };
57828     } catch (Dali::DaliException e) {
57829       {
57830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57831       };
57832     } catch (...) {
57833       {
57834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57835       };
57836     }
57837   }
57838
57839   jresult = (unsigned long)result;
57840   return jresult;
57841 }
57842
57843
57844 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Connect(void * jarg1, void * jarg2) {
57845   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57846   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
57847
57848   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57849   arg2 = (void (*)(Dali::ResourceImage))jarg2;
57850   {
57851     try {
57852       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(arg1,arg2);
57853     } catch (std::out_of_range& e) {
57854       {
57855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57856       };
57857     } catch (std::exception& e) {
57858       {
57859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57860       };
57861     } catch (Dali::DaliException e) {
57862       {
57863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57864       };
57865     } catch (...) {
57866       {
57867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57868       };
57869     }
57870   }
57871
57872 }
57873
57874
57875 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Disconnect(void * jarg1, void * jarg2) {
57876   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57877   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
57878
57879   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57880   arg2 = (void (*)(Dali::ResourceImage))jarg2;
57881   {
57882     try {
57883       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(arg1,arg2);
57884     } catch (std::out_of_range& e) {
57885       {
57886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57887       };
57888     } catch (std::exception& e) {
57889       {
57890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57891       };
57892     } catch (Dali::DaliException e) {
57893       {
57894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57895       };
57896     } catch (...) {
57897       {
57898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57899       };
57900     }
57901   }
57902
57903 }
57904
57905
57906 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Emit(void * jarg1, void * jarg2) {
57907   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57908   Dali::ResourceImage arg2 ;
57909   Dali::ResourceImage *argp2 ;
57910
57911   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57912   argp2 = (Dali::ResourceImage *)jarg2;
57913   if (!argp2) {
57914     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ResourceImage", 0);
57915     return ;
57916   }
57917   arg2 = *argp2;
57918   {
57919     try {
57920       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(arg1,arg2);
57921     } catch (std::out_of_range& e) {
57922       {
57923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57924       };
57925     } catch (std::exception& e) {
57926       {
57927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57928       };
57929     } catch (Dali::DaliException e) {
57930       {
57931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57932       };
57933     } catch (...) {
57934       {
57935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57936       };
57937     }
57938   }
57939
57940 }
57941
57942
57943 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImageSignal() {
57944   void * jresult ;
57945   Dali::Signal< void (Dali::ResourceImage) > *result = 0 ;
57946
57947   {
57948     try {
57949       result = (Dali::Signal< void (Dali::ResourceImage) > *)new Dali::Signal< void (Dali::ResourceImage) >();
57950     } catch (std::out_of_range& e) {
57951       {
57952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57953       };
57954     } catch (std::exception& e) {
57955       {
57956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57957       };
57958     } catch (Dali::DaliException e) {
57959       {
57960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57961       };
57962     } catch (...) {
57963       {
57964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57965       };
57966     }
57967   }
57968
57969   jresult = (void *)result;
57970   return jresult;
57971 }
57972
57973
57974 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImageSignal(void * jarg1) {
57975   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57976
57977   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57978   {
57979     try {
57980       delete arg1;
57981     } catch (std::out_of_range& e) {
57982       {
57983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57984       };
57985     } catch (std::exception& e) {
57986       {
57987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57988       };
57989     } catch (Dali::DaliException e) {
57990       {
57991         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57992       };
57993     } catch (...) {
57994       {
57995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57996       };
57997     }
57998   }
57999
58000 }
58001
58002 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionChangedSignal_Empty(void * jarg1) {
58003   unsigned int jresult ;
58004   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58005   bool result = false;
58006
58007   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58008   {
58009     try {
58010       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);
58011     } catch (std::out_of_range& e) {
58012       {
58013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58014       };
58015     } catch (std::exception& e) {
58016       {
58017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58018       };
58019     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58020   }
58021   jresult = result;
58022   return jresult;
58023 }
58024
58025 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_GetConnectionCount(void * jarg1) {
58026   unsigned long jresult ;
58027   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58028   std::size_t result = 0;
58029
58030   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58031   {
58032     try {
58033       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);
58034     } catch (std::out_of_range& e) {
58035       {
58036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58037       };
58038     } catch (std::exception& e) {
58039       {
58040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58041       };
58042     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58043   }
58044   jresult = (unsigned long)result;
58045   return jresult;
58046 }
58047
58048 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Connect(void * jarg1, void * jarg2) {
58049   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58050   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
58051
58052   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58053   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
58054   {
58055     try {
58056       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Connect(arg1,arg2);
58057     } catch (std::out_of_range& e) {
58058       {
58059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58060       };
58061     } catch (std::exception& e) {
58062       {
58063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58064       };
58065     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58066   }
58067 }
58068
58069 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Disconnect(void * jarg1, void * jarg2) {
58070   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58071   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
58072
58073   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58074   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
58075   {
58076     try {
58077       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Disconnect(arg1,arg2);
58078     } catch (std::out_of_range& e) {
58079       {
58080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58081       };
58082     } catch (std::exception& e) {
58083       {
58084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58085       };
58086     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58087   }
58088 }
58089
58090 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Emit(void * jarg1, void * jarg2, int jarg4) {
58091   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58092   Dali::Actor arg2 ;
58093   //bool arg3 ;
58094   Dali::LayoutDirection::Type arg4 ;
58095   Dali::Actor *argp2 ;
58096
58097   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58098   argp2 = (Dali::Actor *)jarg2;
58099   if (!argp2) {
58100     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58101     return ;
58102   }
58103   arg2 = *argp2;
58104   //arg3 = jarg3 ? true : false;
58105   arg4 = (Dali::LayoutDirection::Type)jarg4;
58106   {
58107     try {
58108       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Emit(arg1,arg2,arg4);
58109     } catch (std::out_of_range& e) {
58110       {
58111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58112       };
58113     } catch (std::exception& e) {
58114       {
58115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58116       };
58117     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58118   }
58119 }
58120
58121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewLayoutDirectionSignal() {
58122   void * jresult ;
58123   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *result = 0 ;
58124
58125   {
58126     try {
58127       result = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)new Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) >();
58128     } catch (std::out_of_range& e) {
58129       {
58130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58131       };
58132     } catch (std::exception& e) {
58133       {
58134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58135       };
58136     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58137   }
58138   jresult = (void *)result;
58139   return jresult;
58140 }
58141
58142 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewLayoutDirectionSignal(void * jarg1) {
58143   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58144
58145   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58146   {
58147     try {
58148       delete arg1;
58149     } catch (std::out_of_range& e) {
58150       {
58151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58152       };
58153     } catch (std::exception& e) {
58154       {
58155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58156       };
58157     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58158   }
58159 }
58160
58161 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Empty(void * jarg1) {
58162   unsigned int jresult ;
58163   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58164   bool result;
58165
58166   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58167   {
58168     try {
58169       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);
58170     } catch (std::out_of_range& e) {
58171       {
58172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58173       };
58174     } catch (std::exception& e) {
58175       {
58176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58177       };
58178     } catch (Dali::DaliException e) {
58179       {
58180         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58181       };
58182     } catch (...) {
58183       {
58184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58185       };
58186     }
58187   }
58188
58189   jresult = result;
58190   return jresult;
58191 }
58192
58193
58194 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_GetConnectionCount(void * jarg1) {
58195   unsigned long jresult ;
58196   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58197   std::size_t result;
58198
58199   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58200   {
58201     try {
58202       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);
58203     } catch (std::out_of_range& e) {
58204       {
58205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58206       };
58207     } catch (std::exception& e) {
58208       {
58209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58210       };
58211     } catch (Dali::DaliException e) {
58212       {
58213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58214       };
58215     } catch (...) {
58216       {
58217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58218       };
58219     }
58220   }
58221
58222   jresult = (unsigned long)result;
58223   return jresult;
58224 }
58225
58226
58227 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Connect(void * jarg1, void * jarg2) {
58228   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58229   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
58230
58231   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58232   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
58233   {
58234     try {
58235       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Connect(arg1,arg2);
58236     } catch (std::out_of_range& e) {
58237       {
58238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58239       };
58240     } catch (std::exception& e) {
58241       {
58242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58243       };
58244     } catch (Dali::DaliException e) {
58245       {
58246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58247       };
58248     } catch (...) {
58249       {
58250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58251       };
58252     }
58253   }
58254
58255 }
58256
58257
58258 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Disconnect(void * jarg1, void * jarg2) {
58259   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58260   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
58261
58262   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58263   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
58264   {
58265     try {
58266       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Disconnect(arg1,arg2);
58267     } catch (std::out_of_range& e) {
58268       {
58269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58270       };
58271     } catch (std::exception& e) {
58272       {
58273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58274       };
58275     } catch (Dali::DaliException e) {
58276       {
58277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58278       };
58279     } catch (...) {
58280       {
58281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58282       };
58283     }
58284   }
58285
58286 }
58287
58288
58289 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, int jarg4) {
58290   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58291   Dali::Actor arg2 ;
58292   bool arg3 ;
58293   Dali::DevelActor::VisibilityChange::Type arg4 ;
58294   Dali::Actor *argp2 ;
58295
58296   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58297   argp2 = (Dali::Actor *)jarg2;
58298   if (!argp2) {
58299     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58300     return ;
58301   }
58302   arg2 = *argp2;
58303   arg3 = jarg3 ? true : false;
58304   arg4 = (Dali::DevelActor::VisibilityChange::Type)jarg4;
58305   {
58306     try {
58307       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Emit(arg1,arg2,arg3,arg4);
58308     } catch (std::out_of_range& e) {
58309       {
58310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58311       };
58312     } catch (std::exception& e) {
58313       {
58314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58315       };
58316     } catch (Dali::DaliException e) {
58317       {
58318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58319       };
58320     } catch (...) {
58321       {
58322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58323       };
58324     }
58325   }
58326
58327 }
58328
58329
58330 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewVisibilityChangedSignal() {
58331   void * jresult ;
58332   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *result = 0 ;
58333
58334   {
58335     try {
58336       result = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)new Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) >();
58337     } catch (std::out_of_range& e) {
58338       {
58339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58340       };
58341     } catch (std::exception& e) {
58342       {
58343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58344       };
58345     } catch (Dali::DaliException e) {
58346       {
58347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58348       };
58349     } catch (...) {
58350       {
58351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58352       };
58353     }
58354   }
58355
58356   jresult = (void *)result;
58357   return jresult;
58358 }
58359
58360
58361 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewVisibilityChangedSignal(void * jarg1) {
58362   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58363
58364   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58365   {
58366     try {
58367       delete arg1;
58368     } catch (std::out_of_range& e) {
58369       {
58370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58371       };
58372     } catch (std::exception& e) {
58373       {
58374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58375       };
58376     } catch (Dali::DaliException e) {
58377       {
58378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58379       };
58380     } catch (...) {
58381       {
58382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58383       };
58384     }
58385   }
58386
58387 }
58388
58389
58390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_0() {
58391   void * jresult ;
58392   Dali::Timer *result = 0 ;
58393
58394   {
58395     try {
58396       result = (Dali::Timer *)new Dali::Timer();
58397     } catch (std::out_of_range& e) {
58398       {
58399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58400       };
58401     } catch (std::exception& e) {
58402       {
58403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58404       };
58405     } catch (Dali::DaliException e) {
58406       {
58407         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58408       };
58409     } catch (...) {
58410       {
58411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58412       };
58413     }
58414   }
58415
58416   jresult = (void *)result;
58417   return jresult;
58418 }
58419
58420
58421 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_New(unsigned int jarg1) {
58422   void * jresult ;
58423   unsigned int arg1 ;
58424   Dali::Timer result;
58425
58426   arg1 = (unsigned int)jarg1;
58427   {
58428     try {
58429       result = Dali::Timer::New(arg1);
58430     } catch (std::out_of_range& e) {
58431       {
58432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58433       };
58434     } catch (std::exception& e) {
58435       {
58436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58437       };
58438     } catch (Dali::DaliException e) {
58439       {
58440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58441       };
58442     } catch (...) {
58443       {
58444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58445       };
58446     }
58447   }
58448
58449   jresult = new Dali::Timer((const Dali::Timer &)result);
58450   return jresult;
58451 }
58452
58453
58454 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_1(void * jarg1) {
58455   void * jresult ;
58456   Dali::Timer *arg1 = 0 ;
58457   Dali::Timer *result = 0 ;
58458
58459   arg1 = (Dali::Timer *)jarg1;
58460   if (!arg1) {
58461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
58462     return 0;
58463   }
58464   {
58465     try {
58466       result = (Dali::Timer *)new Dali::Timer((Dali::Timer const &)*arg1);
58467     } catch (std::out_of_range& e) {
58468       {
58469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58470       };
58471     } catch (std::exception& e) {
58472       {
58473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58474       };
58475     } catch (Dali::DaliException e) {
58476       {
58477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58478       };
58479     } catch (...) {
58480       {
58481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58482       };
58483     }
58484   }
58485
58486   jresult = (void *)result;
58487   return jresult;
58488 }
58489
58490
58491 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_Assign(void * jarg1, void * jarg2) {
58492   void * jresult ;
58493   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58494   Dali::Timer *arg2 = 0 ;
58495   Dali::Timer *result = 0 ;
58496
58497   arg1 = (Dali::Timer *)jarg1;
58498   arg2 = (Dali::Timer *)jarg2;
58499   if (!arg2) {
58500     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
58501     return 0;
58502   }
58503   {
58504     try {
58505       result = (Dali::Timer *) &(arg1)->operator =((Dali::Timer const &)*arg2);
58506     } catch (std::out_of_range& e) {
58507       {
58508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58509       };
58510     } catch (std::exception& e) {
58511       {
58512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58513       };
58514     } catch (Dali::DaliException e) {
58515       {
58516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58517       };
58518     } catch (...) {
58519       {
58520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58521       };
58522     }
58523   }
58524
58525   jresult = (void *)result;
58526   return jresult;
58527 }
58528
58529
58530 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Timer(void * jarg1) {
58531   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58532
58533   arg1 = (Dali::Timer *)jarg1;
58534   {
58535     try {
58536       delete arg1;
58537     } catch (std::out_of_range& e) {
58538       {
58539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58540       };
58541     } catch (std::exception& e) {
58542       {
58543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58544       };
58545     } catch (Dali::DaliException e) {
58546       {
58547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58548       };
58549     } catch (...) {
58550       {
58551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58552       };
58553     }
58554   }
58555
58556 }
58557
58558
58559 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_DownCast(void * jarg1) {
58560   void * jresult ;
58561   Dali::BaseHandle arg1 ;
58562   Dali::BaseHandle *argp1 ;
58563   Dali::Timer result;
58564
58565   argp1 = (Dali::BaseHandle *)jarg1;
58566   if (!argp1) {
58567     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
58568     return 0;
58569   }
58570   arg1 = *argp1;
58571   {
58572     try {
58573       result = Dali::Timer::DownCast(arg1);
58574     } catch (std::out_of_range& e) {
58575       {
58576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58577       };
58578     } catch (std::exception& e) {
58579       {
58580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58581       };
58582     } catch (Dali::DaliException e) {
58583       {
58584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58585       };
58586     } catch (...) {
58587       {
58588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58589       };
58590     }
58591   }
58592
58593   jresult = new Dali::Timer((const Dali::Timer &)result);
58594   return jresult;
58595 }
58596
58597
58598 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Start(void * jarg1) {
58599   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58600
58601   arg1 = (Dali::Timer *)jarg1;
58602   {
58603     try {
58604       (arg1)->Start();
58605     } catch (std::out_of_range& e) {
58606       {
58607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58608       };
58609     } catch (std::exception& e) {
58610       {
58611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58612       };
58613     } catch (Dali::DaliException e) {
58614       {
58615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58616       };
58617     } catch (...) {
58618       {
58619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58620       };
58621     }
58622   }
58623
58624 }
58625
58626
58627 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Stop(void * jarg1) {
58628   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58629
58630   arg1 = (Dali::Timer *)jarg1;
58631   {
58632     try {
58633       (arg1)->Stop();
58634     } catch (std::out_of_range& e) {
58635       {
58636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58637       };
58638     } catch (std::exception& e) {
58639       {
58640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58641       };
58642     } catch (Dali::DaliException e) {
58643       {
58644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58645       };
58646     } catch (...) {
58647       {
58648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58649       };
58650     }
58651   }
58652
58653 }
58654
58655
58656 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_SetInterval(void * jarg1, unsigned int jarg2) {
58657   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58658   unsigned int arg2 ;
58659
58660   arg1 = (Dali::Timer *)jarg1;
58661   arg2 = (unsigned int)jarg2;
58662   {
58663     try {
58664       (arg1)->SetInterval(arg2);
58665     } catch (std::out_of_range& e) {
58666       {
58667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58668       };
58669     } catch (std::exception& e) {
58670       {
58671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58672       };
58673     } catch (Dali::DaliException e) {
58674       {
58675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58676       };
58677     } catch (...) {
58678       {
58679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58680       };
58681     }
58682   }
58683
58684 }
58685
58686
58687 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_GetInterval(void * jarg1) {
58688   unsigned int jresult ;
58689   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58690   unsigned int result;
58691
58692   arg1 = (Dali::Timer *)jarg1;
58693   {
58694     try {
58695       result = (unsigned int)((Dali::Timer const *)arg1)->GetInterval();
58696     } catch (std::out_of_range& e) {
58697       {
58698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58699       };
58700     } catch (std::exception& e) {
58701       {
58702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58703       };
58704     } catch (Dali::DaliException e) {
58705       {
58706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58707       };
58708     } catch (...) {
58709       {
58710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58711       };
58712     }
58713   }
58714
58715   jresult = result;
58716   return jresult;
58717 }
58718
58719
58720 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_IsRunning(void * jarg1) {
58721   unsigned int jresult ;
58722   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58723   bool result;
58724
58725   arg1 = (Dali::Timer *)jarg1;
58726   {
58727     try {
58728       result = (bool)((Dali::Timer const *)arg1)->IsRunning();
58729     } catch (std::out_of_range& e) {
58730       {
58731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58732       };
58733     } catch (std::exception& e) {
58734       {
58735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58736       };
58737     } catch (Dali::DaliException e) {
58738       {
58739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58740       };
58741     } catch (...) {
58742       {
58743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58744       };
58745     }
58746   }
58747
58748   jresult = result;
58749   return jresult;
58750 }
58751
58752
58753 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_TickSignal(void * jarg1) {
58754   void * jresult ;
58755   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58756   Dali::Timer::TimerSignalType *result = 0 ;
58757
58758   arg1 = (Dali::Timer *)jarg1;
58759   {
58760     try {
58761       result = (Dali::Timer::TimerSignalType *) &(arg1)->TickSignal();
58762     } catch (std::out_of_range& e) {
58763       {
58764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58765       };
58766     } catch (std::exception& e) {
58767       {
58768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58769       };
58770     } catch (Dali::DaliException e) {
58771       {
58772         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58773       };
58774     } catch (...) {
58775       {
58776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58777       };
58778     }
58779   }
58780
58781   jresult = (void *)result;
58782   return jresult;
58783 }
58784
58785
58786 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DragAndDropDetector() {
58787   void * jresult ;
58788   Dali::DragAndDropDetector *result = 0 ;
58789
58790   {
58791     try {
58792       result = (Dali::DragAndDropDetector *)new Dali::DragAndDropDetector();
58793     } catch (std::out_of_range& e) {
58794       {
58795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58796       };
58797     } catch (std::exception& e) {
58798       {
58799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58800       };
58801     } catch (Dali::DaliException e) {
58802       {
58803         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58804       };
58805     } catch (...) {
58806       {
58807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58808       };
58809     }
58810   }
58811
58812   jresult = (void *)result;
58813   return jresult;
58814 }
58815
58816
58817 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DragAndDropDetector(void * jarg1) {
58818   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58819
58820   arg1 = (Dali::DragAndDropDetector *)jarg1;
58821   {
58822     try {
58823       delete arg1;
58824     } catch (std::out_of_range& e) {
58825       {
58826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58827       };
58828     } catch (std::exception& e) {
58829       {
58830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58831       };
58832     } catch (Dali::DaliException e) {
58833       {
58834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58835       };
58836     } catch (...) {
58837       {
58838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58839       };
58840     }
58841   }
58842
58843 }
58844
58845
58846 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_GetContent(void * jarg1) {
58847   char * jresult ;
58848   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58849   std::string *result = 0 ;
58850
58851   arg1 = (Dali::DragAndDropDetector *)jarg1;
58852   {
58853     try {
58854       result = (std::string *) &((Dali::DragAndDropDetector const *)arg1)->GetContent();
58855     } catch (std::out_of_range& e) {
58856       {
58857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58858       };
58859     } catch (std::exception& e) {
58860       {
58861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58862       };
58863     } catch (Dali::DaliException e) {
58864       {
58865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58866       };
58867     } catch (...) {
58868       {
58869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58870       };
58871     }
58872   }
58873
58874   jresult = SWIG_csharp_string_callback(result->c_str());
58875   return jresult;
58876 }
58877
58878
58879 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_GetCurrentScreenPosition(void * jarg1) {
58880   void * jresult ;
58881   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58882   Dali::Vector2 result;
58883
58884   arg1 = (Dali::DragAndDropDetector *)jarg1;
58885   {
58886     try {
58887       result = ((Dali::DragAndDropDetector const *)arg1)->GetCurrentScreenPosition();
58888     } catch (std::out_of_range& e) {
58889       {
58890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58891       };
58892     } catch (std::exception& e) {
58893       {
58894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58895       };
58896     } catch (Dali::DaliException e) {
58897       {
58898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58899       };
58900     } catch (...) {
58901       {
58902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58903       };
58904     }
58905   }
58906
58907   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
58908   return jresult;
58909 }
58910
58911
58912 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_EnteredSignal(void * jarg1) {
58913   void * jresult ;
58914   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58915   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
58916
58917   arg1 = (Dali::DragAndDropDetector *)jarg1;
58918   {
58919     try {
58920       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->EnteredSignal();
58921     } catch (std::out_of_range& e) {
58922       {
58923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58924       };
58925     } catch (std::exception& e) {
58926       {
58927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58928       };
58929     } catch (Dali::DaliException e) {
58930       {
58931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58932       };
58933     } catch (...) {
58934       {
58935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58936       };
58937     }
58938   }
58939
58940   jresult = (void *)result;
58941   return jresult;
58942 }
58943
58944
58945 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_ExitedSignal(void * jarg1) {
58946   void * jresult ;
58947   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58948   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
58949
58950   arg1 = (Dali::DragAndDropDetector *)jarg1;
58951   {
58952     try {
58953       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->ExitedSignal();
58954     } catch (std::out_of_range& e) {
58955       {
58956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58957       };
58958     } catch (std::exception& e) {
58959       {
58960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58961       };
58962     } catch (Dali::DaliException e) {
58963       {
58964         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58965       };
58966     } catch (...) {
58967       {
58968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58969       };
58970     }
58971   }
58972
58973   jresult = (void *)result;
58974   return jresult;
58975 }
58976
58977
58978 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_MovedSignal(void * jarg1) {
58979   void * jresult ;
58980   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58981   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
58982
58983   arg1 = (Dali::DragAndDropDetector *)jarg1;
58984   {
58985     try {
58986       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->MovedSignal();
58987     } catch (std::out_of_range& e) {
58988       {
58989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58990       };
58991     } catch (std::exception& e) {
58992       {
58993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58994       };
58995     } catch (Dali::DaliException e) {
58996       {
58997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58998       };
58999     } catch (...) {
59000       {
59001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59002       };
59003     }
59004   }
59005
59006   jresult = (void *)result;
59007   return jresult;
59008 }
59009
59010
59011 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_DroppedSignal(void * jarg1) {
59012   void * jresult ;
59013   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
59014   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
59015
59016   arg1 = (Dali::DragAndDropDetector *)jarg1;
59017   {
59018     try {
59019       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->DroppedSignal();
59020     } catch (std::out_of_range& e) {
59021       {
59022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59023       };
59024     } catch (std::exception& e) {
59025       {
59026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59027       };
59028     } catch (Dali::DaliException e) {
59029       {
59030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59031       };
59032     } catch (...) {
59033       {
59034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59035       };
59036     }
59037   }
59038
59039   jresult = (void *)result;
59040   return jresult;
59041 }
59042
59043
59044 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationExtensions__SWIG_0() {
59045   void * jresult ;
59046   Dali::ApplicationExtensions *result = 0 ;
59047
59048   {
59049     try {
59050       result = (Dali::ApplicationExtensions *)new Dali::ApplicationExtensions();
59051     } catch (std::out_of_range& e) {
59052       {
59053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59054       };
59055     } catch (std::exception& e) {
59056       {
59057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59058       };
59059     } catch (Dali::DaliException e) {
59060       {
59061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59062       };
59063     } catch (...) {
59064       {
59065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59066       };
59067     }
59068   }
59069
59070   jresult = (void *)result;
59071   return jresult;
59072 }
59073
59074
59075 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationExtensions__SWIG_1(void * jarg1) {
59076   void * jresult ;
59077   Dali::Application *arg1 = (Dali::Application *) 0 ;
59078   Dali::ApplicationExtensions *result = 0 ;
59079
59080   arg1 = (Dali::Application *)jarg1;
59081   {
59082     try {
59083       result = (Dali::ApplicationExtensions *)new Dali::ApplicationExtensions(arg1);
59084     } catch (std::out_of_range& e) {
59085       {
59086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59087       };
59088     } catch (std::exception& e) {
59089       {
59090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59091       };
59092     } catch (Dali::DaliException e) {
59093       {
59094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59095       };
59096     } catch (...) {
59097       {
59098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59099       };
59100     }
59101   }
59102
59103   jresult = (void *)result;
59104   return jresult;
59105 }
59106
59107
59108 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ApplicationExtensions(void * jarg1) {
59109   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
59110
59111   arg1 = (Dali::ApplicationExtensions *)jarg1;
59112   {
59113     try {
59114       delete arg1;
59115     } catch (std::out_of_range& e) {
59116       {
59117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59118       };
59119     } catch (std::exception& e) {
59120       {
59121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59122       };
59123     } catch (Dali::DaliException e) {
59124       {
59125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59126       };
59127     } catch (...) {
59128       {
59129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59130       };
59131     }
59132   }
59133
59134 }
59135
59136
59137 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Init(void * jarg1) {
59138   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
59139
59140   arg1 = (Dali::ApplicationExtensions *)jarg1;
59141   {
59142     try {
59143       (arg1)->Init();
59144     } catch (std::out_of_range& e) {
59145       {
59146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59147       };
59148     } catch (std::exception& e) {
59149       {
59150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59151       };
59152     } catch (Dali::DaliException e) {
59153       {
59154         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59155       };
59156     } catch (...) {
59157       {
59158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59159       };
59160     }
59161   }
59162
59163 }
59164
59165 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Start(void * jarg1) {
59166   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
59167
59168   arg1 = (Dali::ApplicationExtensions *)jarg1;
59169   {
59170     try {
59171       (arg1)->Start();
59172     } catch (std::out_of_range& e) {
59173       {
59174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59175       };
59176     } catch (std::exception& e) {
59177       {
59178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59179       };
59180     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; }
59181   }
59182 }
59183
59184 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Terminate(void * jarg1) {
59185   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
59186
59187   arg1 = (Dali::ApplicationExtensions *)jarg1;
59188   {
59189     try {
59190       (arg1)->Terminate();
59191     } catch (std::out_of_range& e) {
59192       {
59193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59194       };
59195     } catch (std::exception& e) {
59196       {
59197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59198       };
59199     } catch (Dali::DaliException e) {
59200       {
59201         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59202       };
59203     } catch (...) {
59204       {
59205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59206       };
59207     }
59208   }
59209
59210 }
59211
59212
59213 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Pause(void * jarg1) {
59214   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
59215
59216   arg1 = (Dali::ApplicationExtensions *)jarg1;
59217   {
59218     try {
59219       (arg1)->Pause();
59220     } catch (std::out_of_range& e) {
59221       {
59222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59223       };
59224     } catch (std::exception& e) {
59225       {
59226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59227       };
59228     } catch (Dali::DaliException e) {
59229       {
59230         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59231       };
59232     } catch (...) {
59233       {
59234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59235       };
59236     }
59237   }
59238
59239 }
59240
59241
59242 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Resume(void * jarg1) {
59243   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
59244
59245   arg1 = (Dali::ApplicationExtensions *)jarg1;
59246   {
59247     try {
59248       (arg1)->Resume();
59249     } catch (std::out_of_range& e) {
59250       {
59251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59252       };
59253     } catch (std::exception& e) {
59254       {
59255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59256       };
59257     } catch (Dali::DaliException e) {
59258       {
59259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59260       };
59261     } catch (...) {
59262       {
59263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59264       };
59265     }
59266   }
59267
59268 }
59269
59270
59271 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_LanguageChange(void * jarg1) {
59272   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
59273
59274   arg1 = (Dali::ApplicationExtensions *)jarg1;
59275   {
59276     try {
59277       (arg1)->LanguageChange();
59278     } catch (std::out_of_range& e) {
59279       {
59280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59281       };
59282     } catch (std::exception& e) {
59283       {
59284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59285       };
59286     } catch (Dali::DaliException e) {
59287       {
59288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59289       };
59290     } catch (...) {
59291       {
59292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59293       };
59294     }
59295   }
59296
59297 }
59298
59299
59300
59301 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Empty(void * jarg1) {
59302   unsigned int jresult ;
59303   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59304   bool result;
59305
59306   arg1 = (Dali::Signal< bool () > *)jarg1;
59307   {
59308     try {
59309       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Empty((Dali::Signal< bool () > const *)arg1);
59310     } catch (std::out_of_range& e) {
59311       {
59312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59313       };
59314     } catch (std::exception& e) {
59315       {
59316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59317       };
59318     } catch (Dali::DaliException e) {
59319       {
59320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59321       };
59322     } catch (...) {
59323       {
59324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59325       };
59326     }
59327   }
59328
59329   jresult = result;
59330   return jresult;
59331 }
59332
59333
59334 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TimerSignalType_GetConnectionCount(void * jarg1) {
59335   unsigned long jresult ;
59336   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59337   std::size_t result;
59338
59339   arg1 = (Dali::Signal< bool () > *)jarg1;
59340   {
59341     try {
59342       result = Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount((Dali::Signal< bool () > const *)arg1);
59343     } catch (std::out_of_range& e) {
59344       {
59345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59346       };
59347     } catch (std::exception& e) {
59348       {
59349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59350       };
59351     } catch (Dali::DaliException e) {
59352       {
59353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59354       };
59355     } catch (...) {
59356       {
59357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59358       };
59359     }
59360   }
59361
59362   jresult = (unsigned long)result;
59363   return jresult;
59364 }
59365
59366
59367 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Connect(void * jarg1, void * jarg2) {
59368   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59369   bool (*arg2)() = (bool (*)()) 0 ;
59370
59371   arg1 = (Dali::Signal< bool () > *)jarg1;
59372   arg2 = (bool (*)())jarg2;
59373   {
59374     try {
59375       Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(arg1,arg2);
59376     } catch (std::out_of_range& e) {
59377       {
59378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59379       };
59380     } catch (std::exception& e) {
59381       {
59382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59383       };
59384     } catch (Dali::DaliException e) {
59385       {
59386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59387       };
59388     } catch (...) {
59389       {
59390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59391       };
59392     }
59393   }
59394
59395 }
59396
59397
59398 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Disconnect(void * jarg1, void * jarg2) {
59399   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59400   bool (*arg2)() = (bool (*)()) 0 ;
59401
59402   arg1 = (Dali::Signal< bool () > *)jarg1;
59403   arg2 = (bool (*)())jarg2;
59404   {
59405     try {
59406       Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(arg1,arg2);
59407     } catch (std::out_of_range& e) {
59408       {
59409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59410       };
59411     } catch (std::exception& e) {
59412       {
59413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59414       };
59415     } catch (Dali::DaliException e) {
59416       {
59417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59418       };
59419     } catch (...) {
59420       {
59421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59422       };
59423     }
59424   }
59425
59426 }
59427
59428
59429 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Emit(void * jarg1) {
59430   unsigned int jresult ;
59431   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59432   bool result;
59433
59434   arg1 = (Dali::Signal< bool () > *)jarg1;
59435   {
59436     try {
59437       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(arg1);
59438     } catch (std::out_of_range& e) {
59439       {
59440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59441       };
59442     } catch (std::exception& e) {
59443       {
59444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59445       };
59446     } catch (Dali::DaliException e) {
59447       {
59448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59449       };
59450     } catch (...) {
59451       {
59452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59453       };
59454     }
59455   }
59456
59457   jresult = result;
59458   return jresult;
59459 }
59460
59461
59462 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimerSignalType() {
59463   void * jresult ;
59464   Dali::Signal< bool () > *result = 0 ;
59465
59466   {
59467     try {
59468       result = (Dali::Signal< bool () > *)new Dali::Signal< bool () >();
59469     } catch (std::out_of_range& e) {
59470       {
59471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59472       };
59473     } catch (std::exception& e) {
59474       {
59475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59476       };
59477     } catch (Dali::DaliException e) {
59478       {
59479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59480       };
59481     } catch (...) {
59482       {
59483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59484       };
59485     }
59486   }
59487
59488   jresult = (void *)result;
59489   return jresult;
59490 }
59491
59492
59493 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimerSignalType(void * jarg1) {
59494   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59495
59496   arg1 = (Dali::Signal< bool () > *)jarg1;
59497   {
59498     try {
59499       delete arg1;
59500     } catch (std::out_of_range& e) {
59501       {
59502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59503       };
59504     } catch (std::exception& e) {
59505       {
59506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59507       };
59508     } catch (Dali::DaliException e) {
59509       {
59510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59511       };
59512     } catch (...) {
59513       {
59514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59515       };
59516     }
59517   }
59518
59519 }
59520
59521
59522 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_TYPE_get() {
59523   int jresult ;
59524   int result;
59525
59526   {
59527     try {
59528       result = (int)Dali::Toolkit::Visual::Property::TYPE;
59529     } catch (std::out_of_range& e) {
59530       {
59531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59532       };
59533     } catch (std::exception& e) {
59534       {
59535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59536       };
59537     } catch (Dali::DaliException e) {
59538       {
59539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59540       };
59541     } catch (...) {
59542       {
59543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59544       };
59545     }
59546   }
59547
59548   jresult = (int)result;
59549   return jresult;
59550 }
59551
59552
59553 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_SHADER_get() {
59554   int jresult ;
59555   int result;
59556
59557   {
59558     try {
59559       result = (int)Dali::Toolkit::Visual::Property::SHADER;
59560     } catch (std::out_of_range& e) {
59561       {
59562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59563       };
59564     } catch (std::exception& e) {
59565       {
59566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59567       };
59568     } catch (Dali::DaliException e) {
59569       {
59570         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59571       };
59572     } catch (...) {
59573       {
59574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59575       };
59576     }
59577   }
59578
59579   jresult = (int)result;
59580   return jresult;
59581 }
59582
59583
59584 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_VERTEX_get() {
59585   int jresult ;
59586   int result;
59587
59588   {
59589     try {
59590       result = (int)Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER;
59591     } catch (std::out_of_range& e) {
59592       {
59593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59594       };
59595     } catch (std::exception& e) {
59596       {
59597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59598       };
59599     } catch (Dali::DaliException e) {
59600       {
59601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59602       };
59603     } catch (...) {
59604       {
59605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59606       };
59607     }
59608   }
59609
59610   jresult = (int)result;
59611   return jresult;
59612 }
59613
59614
59615 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_FRAGMENT_get() {
59616   int jresult ;
59617   int result;
59618
59619   {
59620     try {
59621       result = (int)Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER;
59622     } catch (std::out_of_range& e) {
59623       {
59624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59625       };
59626     } catch (std::exception& e) {
59627       {
59628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59629       };
59630     } catch (Dali::DaliException e) {
59631       {
59632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59633       };
59634     } catch (...) {
59635       {
59636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59637       };
59638     }
59639   }
59640
59641   jresult = (int)result;
59642   return jresult;
59643 }
59644
59645
59646 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_X_get() {
59647   int jresult ;
59648   int result;
59649
59650   {
59651     try {
59652       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_X;
59653     } catch (std::out_of_range& e) {
59654       {
59655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59656       };
59657     } catch (std::exception& e) {
59658       {
59659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59660       };
59661     } catch (Dali::DaliException e) {
59662       {
59663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59664       };
59665     } catch (...) {
59666       {
59667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59668       };
59669     }
59670   }
59671
59672   jresult = (int)result;
59673   return jresult;
59674 }
59675
59676
59677 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_Y_get() {
59678   int jresult ;
59679   int result;
59680
59681   {
59682     try {
59683       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_Y;
59684     } catch (std::out_of_range& e) {
59685       {
59686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59687       };
59688     } catch (std::exception& e) {
59689       {
59690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59691       };
59692     } catch (Dali::DaliException e) {
59693       {
59694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59695       };
59696     } catch (...) {
59697       {
59698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59699       };
59700     }
59701   }
59702
59703   jresult = (int)result;
59704   return jresult;
59705 }
59706
59707
59708 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_HINTS_get() {
59709   int jresult ;
59710   int result;
59711
59712   {
59713     try {
59714       result = (int)Dali::Toolkit::Visual::Shader::Property::HINTS;
59715     } catch (std::out_of_range& e) {
59716       {
59717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59718       };
59719     } catch (std::exception& e) {
59720       {
59721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59722       };
59723     } catch (Dali::DaliException e) {
59724       {
59725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59726       };
59727     } catch (...) {
59728       {
59729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59730       };
59731     }
59732   }
59733
59734   jresult = (int)result;
59735   return jresult;
59736 }
59737
59738
59739 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_COLOR_get() {
59740   int jresult ;
59741   int result;
59742
59743   {
59744     try {
59745       result = (int)Dali::Toolkit::BorderVisual::Property::COLOR;
59746     } catch (std::out_of_range& e) {
59747       {
59748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59749       };
59750     } catch (std::exception& e) {
59751       {
59752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59753       };
59754     } catch (Dali::DaliException e) {
59755       {
59756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59757       };
59758     } catch (...) {
59759       {
59760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59761       };
59762     }
59763   }
59764
59765   jresult = (int)result;
59766   return jresult;
59767 }
59768
59769
59770 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_SIZE_get() {
59771   int jresult ;
59772   int result;
59773
59774   {
59775     try {
59776       result = (int)Dali::Toolkit::BorderVisual::Property::SIZE;
59777     } catch (std::out_of_range& e) {
59778       {
59779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59780       };
59781     } catch (std::exception& e) {
59782       {
59783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59784       };
59785     } catch (Dali::DaliException e) {
59786       {
59787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59788       };
59789     } catch (...) {
59790       {
59791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59792       };
59793     }
59794   }
59795
59796   jresult = (int)result;
59797   return jresult;
59798 }
59799
59800
59801 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_ANTI_ALIASING_get() {
59802   int jresult ;
59803   int result;
59804
59805   {
59806     try {
59807       result = (int)Dali::Toolkit::BorderVisual::Property::ANTI_ALIASING;
59808     } catch (std::out_of_range& e) {
59809       {
59810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59811       };
59812     } catch (std::exception& e) {
59813       {
59814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59815       };
59816     } catch (Dali::DaliException e) {
59817       {
59818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59819       };
59820     } catch (...) {
59821       {
59822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59823       };
59824     }
59825   }
59826
59827   jresult = (int)result;
59828   return jresult;
59829 }
59830
59831
59832 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_COLOR_VISUAL_MIX_COLOR_get() {
59833   int jresult ;
59834   int result;
59835
59836   {
59837     try {
59838       result = (int)Dali::Toolkit::ColorVisual::Property::MIX_COLOR;
59839     } catch (std::out_of_range& e) {
59840       {
59841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59842       };
59843     } catch (std::exception& e) {
59844       {
59845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59846       };
59847     } catch (Dali::DaliException e) {
59848       {
59849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59850       };
59851     } catch (...) {
59852       {
59853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59854       };
59855     }
59856   }
59857
59858   jresult = (int)result;
59859   return jresult;
59860 }
59861
59862
59863 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_START_POSITION_get() {
59864   int jresult ;
59865   int result;
59866
59867   {
59868     try {
59869       result = (int)Dali::Toolkit::GradientVisual::Property::START_POSITION;
59870     } catch (std::out_of_range& e) {
59871       {
59872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59873       };
59874     } catch (std::exception& e) {
59875       {
59876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59877       };
59878     } catch (Dali::DaliException e) {
59879       {
59880         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59881       };
59882     } catch (...) {
59883       {
59884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59885       };
59886     }
59887   }
59888
59889   jresult = (int)result;
59890   return jresult;
59891 }
59892
59893
59894 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_END_POSITION_get() {
59895   int jresult ;
59896   int result;
59897
59898   {
59899     try {
59900       result = (int)Dali::Toolkit::GradientVisual::Property::END_POSITION;
59901     } catch (std::out_of_range& e) {
59902       {
59903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59904       };
59905     } catch (std::exception& e) {
59906       {
59907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59908       };
59909     } catch (Dali::DaliException e) {
59910       {
59911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59912       };
59913     } catch (...) {
59914       {
59915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59916       };
59917     }
59918   }
59919
59920   jresult = (int)result;
59921   return jresult;
59922 }
59923
59924
59925 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_CENTER_get() {
59926   int jresult ;
59927   int result;
59928
59929   {
59930     try {
59931       result = (int)Dali::Toolkit::GradientVisual::Property::CENTER;
59932     } catch (std::out_of_range& e) {
59933       {
59934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59935       };
59936     } catch (std::exception& e) {
59937       {
59938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59939       };
59940     } catch (Dali::DaliException e) {
59941       {
59942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59943       };
59944     } catch (...) {
59945       {
59946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59947       };
59948     }
59949   }
59950
59951   jresult = (int)result;
59952   return jresult;
59953 }
59954
59955
59956 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_RADIUS_get() {
59957   int jresult ;
59958   int result;
59959
59960   {
59961     try {
59962       result = (int)Dali::Toolkit::GradientVisual::Property::RADIUS;
59963     } catch (std::out_of_range& e) {
59964       {
59965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59966       };
59967     } catch (std::exception& e) {
59968       {
59969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59970       };
59971     } catch (Dali::DaliException e) {
59972       {
59973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59974       };
59975     } catch (...) {
59976       {
59977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59978       };
59979     }
59980   }
59981
59982   jresult = (int)result;
59983   return jresult;
59984 }
59985
59986
59987 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_OFFSET_get() {
59988   int jresult ;
59989   int result;
59990
59991   {
59992     try {
59993       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_OFFSET;
59994     } catch (std::out_of_range& e) {
59995       {
59996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59997       };
59998     } catch (std::exception& e) {
59999       {
60000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60001       };
60002     } catch (Dali::DaliException e) {
60003       {
60004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60005       };
60006     } catch (...) {
60007       {
60008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60009       };
60010     }
60011   }
60012
60013   jresult = (int)result;
60014   return jresult;
60015 }
60016
60017
60018 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_COLOR_get() {
60019   int jresult ;
60020   int result;
60021
60022   {
60023     try {
60024       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_COLOR;
60025     } catch (std::out_of_range& e) {
60026       {
60027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60028       };
60029     } catch (std::exception& e) {
60030       {
60031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60032       };
60033     } catch (Dali::DaliException e) {
60034       {
60035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60036       };
60037     } catch (...) {
60038       {
60039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60040       };
60041     }
60042   }
60043
60044   jresult = (int)result;
60045   return jresult;
60046 }
60047
60048
60049 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_UNITS_get() {
60050   int jresult ;
60051   int result;
60052
60053   {
60054     try {
60055       result = (int)Dali::Toolkit::GradientVisual::Property::UNITS;
60056     } catch (std::out_of_range& e) {
60057       {
60058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60059       };
60060     } catch (std::exception& e) {
60061       {
60062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60063       };
60064     } catch (Dali::DaliException e) {
60065       {
60066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60067       };
60068     } catch (...) {
60069       {
60070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60071       };
60072     }
60073   }
60074
60075   jresult = (int)result;
60076   return jresult;
60077 }
60078
60079
60080 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_SPREAD_METHOD_get() {
60081   int jresult ;
60082   int result;
60083
60084   {
60085     try {
60086       result = (int)Dali::Toolkit::GradientVisual::Property::SPREAD_METHOD;
60087     } catch (std::out_of_range& e) {
60088       {
60089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60090       };
60091     } catch (std::exception& e) {
60092       {
60093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60094       };
60095     } catch (Dali::DaliException e) {
60096       {
60097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60098       };
60099     } catch (...) {
60100       {
60101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60102       };
60103     }
60104   }
60105
60106   jresult = (int)result;
60107   return jresult;
60108 }
60109
60110
60111 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_URL_get() {
60112   int jresult ;
60113   int result;
60114
60115   {
60116     try {
60117       result = (int)Dali::Toolkit::ImageVisual::Property::URL;
60118     } catch (std::out_of_range& e) {
60119       {
60120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60121       };
60122     } catch (std::exception& e) {
60123       {
60124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60125       };
60126     } catch (Dali::DaliException e) {
60127       {
60128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60129       };
60130     } catch (...) {
60131       {
60132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60133       };
60134     }
60135   }
60136
60137   jresult = (int)result;
60138   return jresult;
60139 }
60140
60141 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ALPHA_MASK_URL_get() {
60142   int jresult ;
60143   int result;
60144
60145   {
60146     try {
60147       result = (int)Dali::Toolkit::ImageVisual::Property::ALPHA_MASK_URL;
60148     } catch (std::out_of_range& e) {
60149       {
60150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60151       };
60152     } catch (std::exception& e) {
60153       {
60154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60155       };
60156     } catch (Dali::DaliException e) {
60157       {
60158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60159       };
60160     } catch (...) {
60161       {
60162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60163       };
60164     }
60165   }
60166
60167   jresult = (int)result;
60168   return jresult;
60169 }
60170
60171
60172 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BATCH_SIZE_get() {
60173   int jresult ;
60174   int result;
60175   {
60176     try
60177     {
60178       result = (int)Dali::Toolkit::ImageVisual::Property::BATCH_SIZE;
60179     } catch (std::out_of_range& e) {
60180       {
60181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60182       };
60183     } catch (std::exception& e) {
60184       {
60185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60186       };
60187     } catch (Dali::DaliException e) {
60188       {
60189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60190       };
60191     } catch (...) {
60192       {
60193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60194       };
60195     }
60196   }
60197
60198   jresult = (int)result;
60199   return jresult;
60200 }
60201
60202 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CACHE_SIZE_get() {
60203   int jresult ;
60204   int result;
60205   {
60206     try
60207     {
60208       result = (int)Dali::Toolkit::ImageVisual::Property::CACHE_SIZE;
60209     } catch (std::out_of_range& e) {
60210       {
60211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60212       };
60213     } catch (std::exception& e) {
60214       {
60215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60216       };
60217     } catch (Dali::DaliException e) {
60218       {
60219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60220       };
60221     } catch (...) {
60222       {
60223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60224       };
60225     }
60226   }
60227
60228   jresult = (int)result;
60229   return jresult;
60230 }
60231
60232 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FRAME_DELAY_get() {
60233   int jresult ;
60234   int result;
60235   {
60236     try
60237     {
60238       result = (int)Dali::Toolkit::ImageVisual::Property::FRAME_DELAY;
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_LOOP_COUNT_get() {
60263   return (int)Dali::Toolkit::DevelImageVisual::Property::LOOP_COUNT;
60264 }
60265
60266 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_MASK_CONTENT_SCALE_get() {
60267   int jresult ;
60268   int result;
60269   {
60270     try
60271     {
60272       result = (int)Dali::Toolkit::ImageVisual::Property::MASK_CONTENT_SCALE;
60273     } catch (std::out_of_range& e) {
60274       {
60275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60276       };
60277     } catch (std::exception& e) {
60278       {
60279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60280       };
60281     } catch (Dali::DaliException e) {
60282       {
60283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60284       };
60285     } catch (...) {
60286       {
60287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60288       };
60289     }
60290   }
60291
60292   jresult = (int)result;
60293   return jresult;
60294 }
60295
60296 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CROP_TO_MASK_get() {
60297   int jresult ;
60298   int result;
60299   {
60300     try
60301     {
60302       result = (int)Dali::Toolkit::ImageVisual::Property::CROP_TO_MASK;
60303     } catch (std::out_of_range& e) {
60304       {
60305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60306       };
60307     } catch (std::exception& e) {
60308       {
60309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60310       };
60311     } catch (Dali::DaliException e) {
60312       {
60313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60314       };
60315     } catch (...) {
60316       {
60317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60318       };
60319     }
60320   }
60321
60322   jresult = (int)result;
60323   return jresult;
60324 }
60325
60326 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FITTING_MODE_get() {
60327   int jresult ;
60328   int result;
60329
60330   {
60331     try {
60332       result = (int)Dali::Toolkit::ImageVisual::Property::FITTING_MODE;
60333     } catch (std::out_of_range& e) {
60334       {
60335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60336       };
60337     } catch (std::exception& e) {
60338       {
60339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60340       };
60341     } catch (Dali::DaliException e) {
60342       {
60343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60344       };
60345     } catch (...) {
60346       {
60347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60348       };
60349     }
60350   }
60351
60352   jresult = (int)result;
60353   return jresult;
60354 }
60355
60356
60357 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SAMPLING_MODE_get() {
60358   int jresult ;
60359   int result;
60360
60361   {
60362     try {
60363       result = (int)Dali::Toolkit::ImageVisual::Property::SAMPLING_MODE;
60364     } catch (std::out_of_range& e) {
60365       {
60366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60367       };
60368     } catch (std::exception& e) {
60369       {
60370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60371       };
60372     } catch (Dali::DaliException e) {
60373       {
60374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60375       };
60376     } catch (...) {
60377       {
60378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60379       };
60380     }
60381   }
60382
60383   jresult = (int)result;
60384   return jresult;
60385 }
60386
60387 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_RELEASE_POLICY_get() {
60388   int jresult ;
60389   int result;
60390   {
60391     try
60392     {
60393       result = (int)Dali::Toolkit::ImageVisual::Property::RELEASE_POLICY;
60394     } catch (std::out_of_range& e) {
60395       {
60396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60397       };
60398     } catch (std::exception& e) {
60399       {
60400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60401       };
60402     } catch (...) {
60403       {
60404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60405       };
60406     }
60407   }
60408   jresult = (int)result;
60409   return jresult;
60410 }
60411
60412 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOAD_POLICY_get() {
60413   int jresult ;
60414   int result;
60415   {
60416     try
60417     {
60418       result = (int)Dali::Toolkit::ImageVisual::Property::LOAD_POLICY;
60419     } catch (std::out_of_range& e) {
60420       {
60421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60422       };
60423     } catch (std::exception& e) {
60424       {
60425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60426       };
60427     } catch (...) {
60428       {
60429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60430       };
60431     }
60432   }
60433   jresult = (int)result;
60434   return jresult;
60435 }
60436
60437 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ORIENTATION_CORRECTION_get() {
60438   int jresult ;
60439   int result;
60440   {
60441     try
60442     {
60443       result = (int)Dali::Toolkit::ImageVisual::Property::ORIENTATION_CORRECTION;
60444     } catch (std::out_of_range& e) {
60445       {
60446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60447       };
60448     } catch (std::exception& e) {
60449       {
60450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60451       };
60452     } catch (...) {
60453       {
60454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60455       };
60456     }
60457   }
60458   jresult = (int)result;
60459   return jresult;
60460 }
60461
60462
60463 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_URL_get() {
60464   int jresult ;
60465   int result;
60466   {
60467     try
60468     {
60469       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE;
60470     } catch (std::out_of_range& e) {
60471       {
60472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60473       };
60474     } catch (std::exception& e) {
60475       {
60476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60477       };
60478     } catch (...) {
60479       {
60480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60481       };
60482     }
60483   }
60484   jresult = (int)result;
60485   return jresult;
60486 }
60487
60488 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_ALPHA_get() {
60489   int jresult ;
60490   int result;
60491   {
60492     try
60493     {
60494       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE_ALPHA;
60495     } catch (std::out_of_range& e) {
60496       {
60497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60498       };
60499     } catch (std::exception& e) {
60500       {
60501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60502       };
60503     } catch (...) {
60504       {
60505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60506       };
60507     }
60508   }
60509   jresult = (int)result;
60510   return jresult;
60511 }
60512
60513
60514
60515 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_WIDTH_get() {
60516   int jresult ;
60517   int result;
60518
60519   {
60520     try {
60521       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_WIDTH;
60522     } catch (std::out_of_range& e) {
60523       {
60524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60525       };
60526     } catch (std::exception& e) {
60527       {
60528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60529       };
60530     } catch (Dali::DaliException e) {
60531       {
60532         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60533       };
60534     } catch (...) {
60535       {
60536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60537       };
60538     }
60539   }
60540
60541   jresult = (int)result;
60542   return jresult;
60543 }
60544
60545
60546 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_HEIGHT_get() {
60547   int jresult ;
60548   int result;
60549
60550   {
60551     try {
60552       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_HEIGHT;
60553     } catch (std::out_of_range& e) {
60554       {
60555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60556       };
60557     } catch (std::exception& e) {
60558       {
60559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60560       };
60561     } catch (Dali::DaliException e) {
60562       {
60563         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60564       };
60565     } catch (...) {
60566       {
60567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60568       };
60569     }
60570   }
60571
60572   jresult = (int)result;
60573   return jresult;
60574 }
60575
60576
60577 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SYNCHRONOUS_LOADING_get() {
60578   int jresult ;
60579   int result;
60580
60581   {
60582     try {
60583       result = (int)Dali::Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING;
60584     } catch (std::out_of_range& e) {
60585       {
60586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60587       };
60588     } catch (std::exception& e) {
60589       {
60590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60591       };
60592     } catch (Dali::DaliException e) {
60593       {
60594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60595       };
60596     } catch (...) {
60597       {
60598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60599       };
60600     }
60601   }
60602
60603   jresult = (int)result;
60604   return jresult;
60605 }
60606
60607
60608 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BORDER_ONLY_get() {
60609   int jresult ;
60610   int result;
60611
60612   {
60613     try {
60614       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER_ONLY;
60615     } catch (std::out_of_range& e) {
60616       {
60617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60618       };
60619     } catch (std::exception& e) {
60620       {
60621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60622       };
60623     } catch (Dali::DaliException e) {
60624       {
60625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60626       };
60627     } catch (...) {
60628       {
60629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60630       };
60631     }
60632   }
60633
60634   jresult = (int)result;
60635   return jresult;
60636 }
60637
60638
60639 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_PIXEL_AREA_get() {
60640   int jresult ;
60641   int result;
60642
60643   {
60644     try {
60645       result = (int)Dali::Toolkit::ImageVisual::Property::PIXEL_AREA;
60646     } catch (std::out_of_range& e) {
60647       {
60648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60649       };
60650     } catch (std::exception& e) {
60651       {
60652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60653       };
60654     } catch (Dali::DaliException e) {
60655       {
60656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60657       };
60658     } catch (...) {
60659       {
60660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60661       };
60662     }
60663   }
60664
60665   jresult = (int)result;
60666   return jresult;
60667 }
60668
60669
60670 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_U_get() {
60671   int jresult ;
60672   int result;
60673
60674   {
60675     try {
60676       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_U;
60677     } catch (std::out_of_range& e) {
60678       {
60679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60680       };
60681     } catch (std::exception& e) {
60682       {
60683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60684       };
60685     } catch (Dali::DaliException e) {
60686       {
60687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60688       };
60689     } catch (...) {
60690       {
60691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60692       };
60693     }
60694   }
60695
60696   jresult = (int)result;
60697   return jresult;
60698 }
60699
60700
60701 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_V_get() {
60702   int jresult ;
60703   int result;
60704
60705   {
60706     try {
60707       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_V;
60708     } catch (std::out_of_range& e) {
60709       {
60710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60711       };
60712     } catch (std::exception& e) {
60713       {
60714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60715       };
60716     } catch (Dali::DaliException e) {
60717       {
60718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60719       };
60720     } catch (...) {
60721       {
60722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60723       };
60724     }
60725   }
60726
60727   jresult = (int)result;
60728   return jresult;
60729 }
60730
60731 SWIGEXPORT int SWIGSTDCALL CSharp_Image_Visual_BORDER_get() {
60732   int jresult ;
60733   int result;
60734
60735   {
60736     try {
60737       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER;
60738     } catch (std::out_of_range& e) {
60739       {
60740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60741       };
60742     } catch (std::exception& e) {
60743       {
60744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60745       };
60746     } catch (...) {
60747       {
60748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60749       };
60750     }
60751   }
60752   jresult = (int)result;
60753   return jresult;
60754 }
60755
60756 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_OBJECT_URL_get() {
60757   int jresult ;
60758   int result;
60759
60760   {
60761     try {
60762       result = (int)Dali::Toolkit::MeshVisual::Property::OBJECT_URL;
60763     } catch (std::out_of_range& e) {
60764       {
60765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60766       };
60767     } catch (std::exception& e) {
60768       {
60769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60770       };
60771     } catch (Dali::DaliException e) {
60772       {
60773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60774       };
60775     } catch (...) {
60776       {
60777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60778       };
60779     }
60780   }
60781
60782   jresult = (int)result;
60783   return jresult;
60784 }
60785
60786
60787 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_MATERIAL_URL_get() {
60788   int jresult ;
60789   int result;
60790
60791   {
60792     try {
60793       result = (int)Dali::Toolkit::MeshVisual::Property::MATERIAL_URL;
60794     } catch (std::out_of_range& e) {
60795       {
60796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60797       };
60798     } catch (std::exception& e) {
60799       {
60800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60801       };
60802     } catch (Dali::DaliException e) {
60803       {
60804         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60805       };
60806     } catch (...) {
60807       {
60808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60809       };
60810     }
60811   }
60812
60813   jresult = (int)result;
60814   return jresult;
60815 }
60816
60817
60818 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_TEXTURES_PATH_get() {
60819   int jresult ;
60820   int result;
60821
60822   {
60823     try {
60824       result = (int)Dali::Toolkit::MeshVisual::Property::TEXTURES_PATH;
60825     } catch (std::out_of_range& e) {
60826       {
60827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60828       };
60829     } catch (std::exception& e) {
60830       {
60831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60832       };
60833     } catch (Dali::DaliException e) {
60834       {
60835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60836       };
60837     } catch (...) {
60838       {
60839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60840       };
60841     }
60842   }
60843
60844   jresult = (int)result;
60845   return jresult;
60846 }
60847
60848
60849 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_SHADING_MODE_get() {
60850   int jresult ;
60851   int result;
60852
60853   {
60854     try {
60855       result = (int)Dali::Toolkit::MeshVisual::Property::SHADING_MODE;
60856     } catch (std::out_of_range& e) {
60857       {
60858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60859       };
60860     } catch (std::exception& e) {
60861       {
60862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60863       };
60864     } catch (Dali::DaliException e) {
60865       {
60866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60867       };
60868     } catch (...) {
60869       {
60870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60871       };
60872     }
60873   }
60874
60875   jresult = (int)result;
60876   return jresult;
60877 }
60878
60879
60880 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_MIPMAPPING_get() {
60881   int jresult ;
60882   int result;
60883
60884   {
60885     try {
60886       result = (int)Dali::Toolkit::MeshVisual::Property::USE_MIPMAPPING;
60887     } catch (std::out_of_range& e) {
60888       {
60889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60890       };
60891     } catch (std::exception& e) {
60892       {
60893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60894       };
60895     } catch (Dali::DaliException e) {
60896       {
60897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60898       };
60899     } catch (...) {
60900       {
60901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60902       };
60903     }
60904   }
60905
60906   jresult = (int)result;
60907   return jresult;
60908 }
60909
60910
60911 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_SOFT_NORMALS_get() {
60912   int jresult ;
60913   int result;
60914
60915   {
60916     try {
60917       result = (int)Dali::Toolkit::MeshVisual::Property::USE_SOFT_NORMALS;
60918     } catch (std::out_of_range& e) {
60919       {
60920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60921       };
60922     } catch (std::exception& e) {
60923       {
60924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60925       };
60926     } catch (Dali::DaliException e) {
60927       {
60928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60929       };
60930     } catch (...) {
60931       {
60932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60933       };
60934     }
60935   }
60936
60937   jresult = (int)result;
60938   return jresult;
60939 }
60940
60941
60942 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_LIGHT_POSITION_get() {
60943   int jresult ;
60944   int result;
60945
60946   {
60947     try {
60948       result = (int)Dali::Toolkit::MeshVisual::Property::LIGHT_POSITION;
60949     } catch (std::out_of_range& e) {
60950       {
60951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60952       };
60953     } catch (std::exception& e) {
60954       {
60955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60956       };
60957     } catch (Dali::DaliException e) {
60958       {
60959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60960       };
60961     } catch (...) {
60962       {
60963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60964       };
60965     }
60966   }
60967
60968   jresult = (int)result;
60969   return jresult;
60970 }
60971
60972
60973 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SHAPE_get() {
60974   int jresult ;
60975   int result;
60976
60977   {
60978     try {
60979       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SHAPE;
60980     } catch (std::out_of_range& e) {
60981       {
60982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60983       };
60984     } catch (std::exception& e) {
60985       {
60986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60987       };
60988     } catch (Dali::DaliException e) {
60989       {
60990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60991       };
60992     } catch (...) {
60993       {
60994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60995       };
60996     }
60997   }
60998
60999   jresult = (int)result;
61000   return jresult;
61001 }
61002
61003
61004 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_MIX_COLOR_get() {
61005   int jresult ;
61006   int result;
61007
61008   {
61009     try {
61010       result = (int)Dali::Toolkit::PrimitiveVisual::Property::MIX_COLOR;
61011     } catch (std::out_of_range& e) {
61012       {
61013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61014       };
61015     } catch (std::exception& e) {
61016       {
61017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61018       };
61019     } catch (Dali::DaliException e) {
61020       {
61021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61022       };
61023     } catch (...) {
61024       {
61025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61026       };
61027     }
61028   }
61029
61030   jresult = (int)result;
61031   return jresult;
61032 }
61033
61034
61035 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SLICES_get() {
61036   int jresult ;
61037   int result;
61038
61039   {
61040     try {
61041       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SLICES;
61042     } catch (std::out_of_range& e) {
61043       {
61044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61045       };
61046     } catch (std::exception& e) {
61047       {
61048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61049       };
61050     } catch (Dali::DaliException e) {
61051       {
61052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61053       };
61054     } catch (...) {
61055       {
61056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61057       };
61058     }
61059   }
61060
61061   jresult = (int)result;
61062   return jresult;
61063 }
61064
61065
61066 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_STACKS_get() {
61067   int jresult ;
61068   int result;
61069
61070   {
61071     try {
61072       result = (int)Dali::Toolkit::PrimitiveVisual::Property::STACKS;
61073     } catch (std::out_of_range& e) {
61074       {
61075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61076       };
61077     } catch (std::exception& e) {
61078       {
61079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61080       };
61081     } catch (Dali::DaliException e) {
61082       {
61083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61084       };
61085     } catch (...) {
61086       {
61087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61088       };
61089     }
61090   }
61091
61092   jresult = (int)result;
61093   return jresult;
61094 }
61095
61096
61097 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_TOP_RADIUS_get() {
61098   int jresult ;
61099   int result;
61100
61101   {
61102     try {
61103       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_TOP_RADIUS;
61104     } catch (std::out_of_range& e) {
61105       {
61106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61107       };
61108     } catch (std::exception& e) {
61109       {
61110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61111       };
61112     } catch (Dali::DaliException e) {
61113       {
61114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61115       };
61116     } catch (...) {
61117       {
61118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61119       };
61120     }
61121   }
61122
61123   jresult = (int)result;
61124   return jresult;
61125 }
61126
61127
61128 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_BOTTOM_RADIUS_get() {
61129   int jresult ;
61130   int result;
61131
61132   {
61133     try {
61134       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS;
61135     } catch (std::out_of_range& e) {
61136       {
61137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61138       };
61139     } catch (std::exception& e) {
61140       {
61141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61142       };
61143     } catch (Dali::DaliException e) {
61144       {
61145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61146       };
61147     } catch (...) {
61148       {
61149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61150       };
61151     }
61152   }
61153
61154   jresult = (int)result;
61155   return jresult;
61156 }
61157
61158
61159 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_HEIGHT_get() {
61160   int jresult ;
61161   int result;
61162
61163   {
61164     try {
61165       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_HEIGHT;
61166     } catch (std::out_of_range& e) {
61167       {
61168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61169       };
61170     } catch (std::exception& e) {
61171       {
61172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61173       };
61174     } catch (Dali::DaliException e) {
61175       {
61176         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61177       };
61178     } catch (...) {
61179       {
61180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61181       };
61182     }
61183   }
61184
61185   jresult = (int)result;
61186   return jresult;
61187 }
61188
61189
61190 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_RADIUS_get() {
61191   int jresult ;
61192   int result;
61193
61194   {
61195     try {
61196       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_RADIUS;
61197     } catch (std::out_of_range& e) {
61198       {
61199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61200       };
61201     } catch (std::exception& e) {
61202       {
61203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61204       };
61205     } catch (Dali::DaliException e) {
61206       {
61207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61208       };
61209     } catch (...) {
61210       {
61211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61212       };
61213     }
61214   }
61215
61216   jresult = (int)result;
61217   return jresult;
61218 }
61219
61220
61221 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_DIMENSIONS_get() {
61222   int jresult ;
61223   int result;
61224
61225   {
61226     try {
61227       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_DIMENSIONS;
61228     } catch (std::out_of_range& e) {
61229       {
61230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61231       };
61232     } catch (std::exception& e) {
61233       {
61234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61235       };
61236     } catch (Dali::DaliException e) {
61237       {
61238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61239       };
61240     } catch (...) {
61241       {
61242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61243       };
61244     }
61245   }
61246
61247   jresult = (int)result;
61248   return jresult;
61249 }
61250
61251
61252 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_PERCENTAGE_get() {
61253   int jresult ;
61254   int result;
61255
61256   {
61257     try {
61258       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_PERCENTAGE;
61259     } catch (std::out_of_range& e) {
61260       {
61261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61262       };
61263     } catch (std::exception& e) {
61264       {
61265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61266       };
61267     } catch (Dali::DaliException e) {
61268       {
61269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61270       };
61271     } catch (...) {
61272       {
61273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61274       };
61275     }
61276   }
61277
61278   jresult = (int)result;
61279   return jresult;
61280 }
61281
61282
61283 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_SMOOTHNESS_get() {
61284   int jresult ;
61285   int result;
61286
61287   {
61288     try {
61289       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_SMOOTHNESS;
61290     } catch (std::out_of_range& e) {
61291       {
61292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61293       };
61294     } catch (std::exception& e) {
61295       {
61296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61297       };
61298     } catch (Dali::DaliException e) {
61299       {
61300         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61301       };
61302     } catch (...) {
61303       {
61304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61305       };
61306     }
61307   }
61308
61309   jresult = (int)result;
61310   return jresult;
61311 }
61312
61313
61314 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_LIGHT_POSITION_get() {
61315   int jresult ;
61316   int result;
61317
61318   {
61319     try {
61320       result = (int)Dali::Toolkit::PrimitiveVisual::Property::LIGHT_POSITION;
61321     } catch (std::out_of_range& e) {
61322       {
61323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61324       };
61325     } catch (std::exception& e) {
61326       {
61327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61328       };
61329     } catch (Dali::DaliException e) {
61330       {
61331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61332       };
61333     } catch (...) {
61334       {
61335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61336       };
61337     }
61338   }
61339
61340   jresult = (int)result;
61341   return jresult;
61342 }
61343
61344
61345 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_get() {
61346   int jresult ;
61347   int result;
61348
61349   {
61350     try {
61351       result = (int)Dali::Toolkit::TextVisual::Property::TEXT;
61352     } catch (std::out_of_range& e) {
61353       {
61354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61355       };
61356     } catch (std::exception& e) {
61357       {
61358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61359       };
61360     } catch (Dali::DaliException e) {
61361       {
61362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61363       };
61364     } catch (...) {
61365       {
61366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61367       };
61368     }
61369   }
61370
61371   jresult = (int)result;
61372   return jresult;
61373 }
61374
61375
61376 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_FAMILY_get() {
61377   int jresult ;
61378   int result;
61379
61380   {
61381     try {
61382       result = (int)Dali::Toolkit::TextVisual::Property::FONT_FAMILY;
61383     } catch (std::out_of_range& e) {
61384       {
61385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61386       };
61387     } catch (std::exception& e) {
61388       {
61389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61390       };
61391     } catch (Dali::DaliException e) {
61392       {
61393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61394       };
61395     } catch (...) {
61396       {
61397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61398       };
61399     }
61400   }
61401
61402   jresult = (int)result;
61403   return jresult;
61404 }
61405
61406
61407 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_STYLE_get() {
61408   int jresult ;
61409   int result;
61410
61411   {
61412     try {
61413       result = (int)Dali::Toolkit::TextVisual::Property::FONT_STYLE;
61414     } catch (std::out_of_range& e) {
61415       {
61416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61417       };
61418     } catch (std::exception& e) {
61419       {
61420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61421       };
61422     } catch (Dali::DaliException e) {
61423       {
61424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61425       };
61426     } catch (...) {
61427       {
61428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61429       };
61430     }
61431   }
61432
61433   jresult = (int)result;
61434   return jresult;
61435 }
61436
61437
61438 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_POINT_SIZE_get() {
61439   int jresult ;
61440   int result;
61441
61442   {
61443     try {
61444       result = (int)Dali::Toolkit::TextVisual::Property::POINT_SIZE;
61445     } catch (std::out_of_range& e) {
61446       {
61447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61448       };
61449     } catch (std::exception& e) {
61450       {
61451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61452       };
61453     } catch (Dali::DaliException e) {
61454       {
61455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61456       };
61457     } catch (...) {
61458       {
61459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61460       };
61461     }
61462   }
61463
61464   jresult = (int)result;
61465   return jresult;
61466 }
61467
61468
61469 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_MULTI_LINE_get() {
61470   int jresult ;
61471   int result;
61472
61473   {
61474     try {
61475       result = (int)Dali::Toolkit::TextVisual::Property::MULTI_LINE;
61476     } catch (std::out_of_range& e) {
61477       {
61478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61479       };
61480     } catch (std::exception& e) {
61481       {
61482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61483       };
61484     } catch (Dali::DaliException e) {
61485       {
61486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61487       };
61488     } catch (...) {
61489       {
61490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61491       };
61492     }
61493   }
61494
61495   jresult = (int)result;
61496   return jresult;
61497 }
61498
61499
61500 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_HORIZONTAL_ALIGNMENT_get() {
61501   int jresult ;
61502   int result;
61503
61504   {
61505     try {
61506       result = (int)Dali::Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT;
61507     } catch (std::out_of_range& e) {
61508       {
61509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61510       };
61511     } catch (std::exception& e) {
61512       {
61513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61514       };
61515     } catch (Dali::DaliException e) {
61516       {
61517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61518       };
61519     } catch (...) {
61520       {
61521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61522       };
61523     }
61524   }
61525
61526   jresult = (int)result;
61527   return jresult;
61528 }
61529
61530
61531 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_VERTICAL_ALIGNMENT_get() {
61532   int jresult ;
61533   int result;
61534
61535   {
61536     try {
61537       result = (int)Dali::Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT;
61538     } catch (std::out_of_range& e) {
61539       {
61540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61541       };
61542     } catch (std::exception& e) {
61543       {
61544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61545       };
61546     } catch (Dali::DaliException e) {
61547       {
61548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61549       };
61550     } catch (...) {
61551       {
61552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61553       };
61554     }
61555   }
61556
61557   jresult = (int)result;
61558   return jresult;
61559 }
61560
61561
61562 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_COLOR_get() {
61563   int jresult ;
61564   int result;
61565
61566   {
61567     try {
61568       result = (int)Dali::Toolkit::TextVisual::Property::TEXT_COLOR;
61569     } catch (std::out_of_range& e) {
61570       {
61571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61572       };
61573     } catch (std::exception& e) {
61574       {
61575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61576       };
61577     } catch (Dali::DaliException e) {
61578       {
61579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61580       };
61581     } catch (...) {
61582       {
61583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61584       };
61585     }
61586   }
61587
61588   jresult = (int)result;
61589   return jresult;
61590 }
61591
61592
61593 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_ENABLE_MARKUP_get() {
61594   int jresult ;
61595   int result;
61596
61597   {
61598     try {
61599       result = (int)Dali::Toolkit::TextVisual::Property::ENABLE_MARKUP;
61600     } catch (std::out_of_range& e) {
61601       {
61602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61603       };
61604     } catch (std::exception& e) {
61605       {
61606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61607       };
61608     } catch (Dali::DaliException e) {
61609       {
61610         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61611       };
61612     } catch (...) {
61613       {
61614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61615       };
61616     }
61617   }
61618
61619   jresult = (int)result;
61620   return jresult;
61621 }
61622
61623
61624 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Builder() {
61625   void * jresult ;
61626   Dali::Toolkit::Builder *result = 0 ;
61627
61628   {
61629     try {
61630       result = (Dali::Toolkit::Builder *)new Dali::Toolkit::Builder();
61631     } catch (std::out_of_range& e) {
61632       {
61633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61634       };
61635     } catch (std::exception& e) {
61636       {
61637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61638       };
61639     } catch (Dali::DaliException e) {
61640       {
61641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61642       };
61643     } catch (...) {
61644       {
61645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61646       };
61647     }
61648   }
61649
61650   jresult = (void *)result;
61651   return jresult;
61652 }
61653
61654
61655 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_New() {
61656   void * jresult ;
61657   Dali::Toolkit::Builder result;
61658
61659   {
61660     try {
61661       result = Dali::Toolkit::Builder::New();
61662     } catch (std::out_of_range& e) {
61663       {
61664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61665       };
61666     } catch (std::exception& e) {
61667       {
61668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61669       };
61670     } catch (Dali::DaliException e) {
61671       {
61672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61673       };
61674     } catch (...) {
61675       {
61676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61677       };
61678     }
61679   }
61680
61681   jresult = new Dali::Toolkit::Builder((const Dali::Toolkit::Builder &)result);
61682   return jresult;
61683 }
61684
61685
61686 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Builder(void * jarg1) {
61687   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61688
61689   arg1 = (Dali::Toolkit::Builder *)jarg1;
61690   {
61691     try {
61692       delete arg1;
61693     } catch (std::out_of_range& e) {
61694       {
61695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61696       };
61697     } catch (std::exception& e) {
61698       {
61699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61700       };
61701     } catch (Dali::DaliException e) {
61702       {
61703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61704       };
61705     } catch (...) {
61706       {
61707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61708       };
61709     }
61710   }
61711
61712 }
61713
61714
61715 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_0(void * jarg1, char * jarg2, int jarg3) {
61716   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61717   std::string *arg2 = 0 ;
61718   Dali::Toolkit::Builder::UIFormat arg3 ;
61719
61720   arg1 = (Dali::Toolkit::Builder *)jarg1;
61721   if (!jarg2) {
61722     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61723     return ;
61724   }
61725   std::string arg2_str(jarg2);
61726   arg2 = &arg2_str;
61727   arg3 = (Dali::Toolkit::Builder::UIFormat)jarg3;
61728   {
61729     try {
61730       (arg1)->LoadFromString((std::string const &)*arg2,arg3);
61731     } catch (std::out_of_range& e) {
61732       {
61733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61734       };
61735     } catch (std::exception& e) {
61736       {
61737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61738       };
61739     } catch (Dali::DaliException e) {
61740       {
61741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61742       };
61743     } catch (...) {
61744       {
61745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61746       };
61747     }
61748   }
61749
61750
61751   //argout typemap for const std::string&
61752
61753 }
61754
61755
61756 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_1(void * jarg1, char * jarg2) {
61757   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61758   std::string *arg2 = 0 ;
61759
61760   arg1 = (Dali::Toolkit::Builder *)jarg1;
61761   if (!jarg2) {
61762     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61763     return ;
61764   }
61765   std::string arg2_str(jarg2);
61766   arg2 = &arg2_str;
61767   {
61768     try {
61769       (arg1)->LoadFromString((std::string const &)*arg2);
61770     } catch (std::out_of_range& e) {
61771       {
61772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61773       };
61774     } catch (std::exception& e) {
61775       {
61776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61777       };
61778     } catch (Dali::DaliException e) {
61779       {
61780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61781       };
61782     } catch (...) {
61783       {
61784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61785       };
61786     }
61787   }
61788
61789
61790   //argout typemap for const std::string&
61791
61792 }
61793
61794
61795 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstants(void * jarg1, void * jarg2) {
61796   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61797   Dali::Property::Map *arg2 = 0 ;
61798
61799   arg1 = (Dali::Toolkit::Builder *)jarg1;
61800   arg2 = (Dali::Property::Map *)jarg2;
61801   if (!arg2) {
61802     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
61803     return ;
61804   }
61805   {
61806     try {
61807       (arg1)->AddConstants((Dali::Property::Map const &)*arg2);
61808     } catch (std::out_of_range& e) {
61809       {
61810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61811       };
61812     } catch (std::exception& e) {
61813       {
61814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61815       };
61816     } catch (Dali::DaliException e) {
61817       {
61818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61819       };
61820     } catch (...) {
61821       {
61822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61823       };
61824     }
61825   }
61826
61827 }
61828
61829
61830 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstant(void * jarg1, char * jarg2, void * jarg3) {
61831   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61832   std::string *arg2 = 0 ;
61833   Dali::Property::Value *arg3 = 0 ;
61834
61835   arg1 = (Dali::Toolkit::Builder *)jarg1;
61836   if (!jarg2) {
61837     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61838     return ;
61839   }
61840   std::string arg2_str(jarg2);
61841   arg2 = &arg2_str;
61842   arg3 = (Dali::Property::Value *)jarg3;
61843   if (!arg3) {
61844     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
61845     return ;
61846   }
61847   {
61848     try {
61849       (arg1)->AddConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
61850     } catch (std::out_of_range& e) {
61851       {
61852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61853       };
61854     } catch (std::exception& e) {
61855       {
61856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61857       };
61858     } catch (Dali::DaliException e) {
61859       {
61860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61861       };
61862     } catch (...) {
61863       {
61864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61865       };
61866     }
61867   }
61868
61869
61870   //argout typemap for const std::string&
61871
61872 }
61873
61874
61875 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstants(void * jarg1) {
61876   void * jresult ;
61877   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61878   Dali::Property::Map *result = 0 ;
61879
61880   arg1 = (Dali::Toolkit::Builder *)jarg1;
61881   {
61882     try {
61883       result = (Dali::Property::Map *) &((Dali::Toolkit::Builder const *)arg1)->GetConstants();
61884     } catch (std::out_of_range& e) {
61885       {
61886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61887       };
61888     } catch (std::exception& e) {
61889       {
61890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61891       };
61892     } catch (Dali::DaliException e) {
61893       {
61894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61895       };
61896     } catch (...) {
61897       {
61898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61899       };
61900     }
61901   }
61902
61903   jresult = (void *)result;
61904   return jresult;
61905 }
61906
61907
61908 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstant(void * jarg1, char * jarg2) {
61909   void * jresult ;
61910   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61911   std::string *arg2 = 0 ;
61912   Dali::Property::Value *result = 0 ;
61913
61914   arg1 = (Dali::Toolkit::Builder *)jarg1;
61915   if (!jarg2) {
61916     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61917     return 0;
61918   }
61919   std::string arg2_str(jarg2);
61920   arg2 = &arg2_str;
61921   {
61922     try {
61923       result = (Dali::Property::Value *) &((Dali::Toolkit::Builder const *)arg1)->GetConstant((std::string const &)*arg2);
61924     } catch (std::out_of_range& e) {
61925       {
61926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61927       };
61928     } catch (std::exception& e) {
61929       {
61930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61931       };
61932     } catch (Dali::DaliException e) {
61933       {
61934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61935       };
61936     } catch (...) {
61937       {
61938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61939       };
61940     }
61941   }
61942
61943   jresult = (void *)result;
61944
61945   //argout typemap for const std::string&
61946
61947   return jresult;
61948 }
61949
61950
61951 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_0(void * jarg1, char * jarg2) {
61952   void * jresult ;
61953   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61954   std::string *arg2 = 0 ;
61955   Dali::Animation result;
61956
61957   arg1 = (Dali::Toolkit::Builder *)jarg1;
61958   if (!jarg2) {
61959     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61960     return 0;
61961   }
61962   std::string arg2_str(jarg2);
61963   arg2 = &arg2_str;
61964   {
61965     try {
61966       result = (arg1)->CreateAnimation((std::string const &)*arg2);
61967     } catch (std::out_of_range& e) {
61968       {
61969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61970       };
61971     } catch (std::exception& e) {
61972       {
61973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61974       };
61975     } catch (Dali::DaliException e) {
61976       {
61977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61978       };
61979     } catch (...) {
61980       {
61981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61982       };
61983     }
61984   }
61985
61986   jresult = new Dali::Animation((const Dali::Animation &)result);
61987
61988   //argout typemap for const std::string&
61989
61990   return jresult;
61991 }
61992
61993
61994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
61995   void * jresult ;
61996   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61997   std::string *arg2 = 0 ;
61998   Dali::Property::Map *arg3 = 0 ;
61999   Dali::Animation result;
62000
62001   arg1 = (Dali::Toolkit::Builder *)jarg1;
62002   if (!jarg2) {
62003     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62004     return 0;
62005   }
62006   std::string arg2_str(jarg2);
62007   arg2 = &arg2_str;
62008   arg3 = (Dali::Property::Map *)jarg3;
62009   if (!arg3) {
62010     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
62011     return 0;
62012   }
62013   {
62014     try {
62015       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
62016     } catch (std::out_of_range& e) {
62017       {
62018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62019       };
62020     } catch (std::exception& e) {
62021       {
62022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62023       };
62024     } catch (Dali::DaliException e) {
62025       {
62026         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62027       };
62028     } catch (...) {
62029       {
62030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62031       };
62032     }
62033   }
62034
62035   jresult = new Dali::Animation((const Dali::Animation &)result);
62036
62037   //argout typemap for const std::string&
62038
62039   return jresult;
62040 }
62041
62042
62043 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
62044   void * jresult ;
62045   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62046   std::string *arg2 = 0 ;
62047   Dali::Actor arg3 ;
62048   Dali::Actor *argp3 ;
62049   Dali::Animation result;
62050
62051   arg1 = (Dali::Toolkit::Builder *)jarg1;
62052   if (!jarg2) {
62053     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62054     return 0;
62055   }
62056   std::string arg2_str(jarg2);
62057   arg2 = &arg2_str;
62058   argp3 = (Dali::Actor *)jarg3;
62059   if (!argp3) {
62060     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62061     return 0;
62062   }
62063   arg3 = *argp3;
62064   {
62065     try {
62066       result = (arg1)->CreateAnimation((std::string const &)*arg2,arg3);
62067     } catch (std::out_of_range& e) {
62068       {
62069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62070       };
62071     } catch (std::exception& e) {
62072       {
62073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62074       };
62075     } catch (Dali::DaliException e) {
62076       {
62077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62078       };
62079     } catch (...) {
62080       {
62081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62082       };
62083     }
62084   }
62085
62086   jresult = new Dali::Animation((const Dali::Animation &)result);
62087
62088   //argout typemap for const std::string&
62089
62090   return jresult;
62091 }
62092
62093
62094 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_3(void * jarg1, char * jarg2, void * jarg3, void * jarg4) {
62095   void * jresult ;
62096   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62097   std::string *arg2 = 0 ;
62098   Dali::Property::Map *arg3 = 0 ;
62099   Dali::Actor arg4 ;
62100   Dali::Actor *argp4 ;
62101   Dali::Animation result;
62102
62103   arg1 = (Dali::Toolkit::Builder *)jarg1;
62104   if (!jarg2) {
62105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62106     return 0;
62107   }
62108   std::string arg2_str(jarg2);
62109   arg2 = &arg2_str;
62110   arg3 = (Dali::Property::Map *)jarg3;
62111   if (!arg3) {
62112     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
62113     return 0;
62114   }
62115   argp4 = (Dali::Actor *)jarg4;
62116   if (!argp4) {
62117     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62118     return 0;
62119   }
62120   arg4 = *argp4;
62121   {
62122     try {
62123       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3,arg4);
62124     } catch (std::out_of_range& e) {
62125       {
62126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62127       };
62128     } catch (std::exception& e) {
62129       {
62130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62131       };
62132     } catch (Dali::DaliException e) {
62133       {
62134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62135       };
62136     } catch (...) {
62137       {
62138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62139       };
62140     }
62141   }
62142
62143   jresult = new Dali::Animation((const Dali::Animation &)result);
62144
62145   //argout typemap for const std::string&
62146
62147   return jresult;
62148 }
62149
62150
62151 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_0(void * jarg1, char * jarg2) {
62152   void * jresult ;
62153   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62154   std::string *arg2 = 0 ;
62155   Dali::BaseHandle result;
62156
62157   arg1 = (Dali::Toolkit::Builder *)jarg1;
62158   if (!jarg2) {
62159     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62160     return 0;
62161   }
62162   std::string arg2_str(jarg2);
62163   arg2 = &arg2_str;
62164   {
62165     try {
62166       result = (arg1)->Create((std::string const &)*arg2);
62167     } catch (std::out_of_range& e) {
62168       {
62169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62170       };
62171     } catch (std::exception& e) {
62172       {
62173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62174       };
62175     } catch (Dali::DaliException e) {
62176       {
62177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62178       };
62179     } catch (...) {
62180       {
62181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62182       };
62183     }
62184   }
62185
62186   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
62187
62188   //argout typemap for const std::string&
62189
62190   return jresult;
62191 }
62192
62193
62194 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
62195   void * jresult ;
62196   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62197   std::string *arg2 = 0 ;
62198   Dali::Property::Map *arg3 = 0 ;
62199   Dali::BaseHandle result;
62200
62201   arg1 = (Dali::Toolkit::Builder *)jarg1;
62202   if (!jarg2) {
62203     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62204     return 0;
62205   }
62206   std::string arg2_str(jarg2);
62207   arg2 = &arg2_str;
62208   arg3 = (Dali::Property::Map *)jarg3;
62209   if (!arg3) {
62210     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
62211     return 0;
62212   }
62213   {
62214     try {
62215       result = (arg1)->Create((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
62216     } catch (std::out_of_range& e) {
62217       {
62218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62219       };
62220     } catch (std::exception& e) {
62221       {
62222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62223       };
62224     } catch (Dali::DaliException e) {
62225       {
62226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62227       };
62228     } catch (...) {
62229       {
62230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62231       };
62232     }
62233   }
62234
62235   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
62236
62237   //argout typemap for const std::string&
62238
62239   return jresult;
62240 }
62241
62242
62243 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateFromJson(void * jarg1, char * jarg2) {
62244   void * jresult ;
62245   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62246   std::string *arg2 = 0 ;
62247   Dali::BaseHandle result;
62248
62249   arg1 = (Dali::Toolkit::Builder *)jarg1;
62250   if (!jarg2) {
62251     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62252     return 0;
62253   }
62254   std::string arg2_str(jarg2);
62255   arg2 = &arg2_str;
62256   {
62257     try {
62258       result = (arg1)->CreateFromJson((std::string const &)*arg2);
62259     } catch (std::out_of_range& e) {
62260       {
62261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62262       };
62263     } catch (std::exception& e) {
62264       {
62265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62266       };
62267     } catch (Dali::DaliException e) {
62268       {
62269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62270       };
62271     } catch (...) {
62272       {
62273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62274       };
62275     }
62276   }
62277
62278   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
62279
62280   //argout typemap for const std::string&
62281
62282   return jresult;
62283 }
62284
62285
62286 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyStyle(void * jarg1, char * jarg2, void * jarg3) {
62287   unsigned int jresult ;
62288   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62289   std::string *arg2 = 0 ;
62290   Dali::Handle *arg3 = 0 ;
62291   bool result;
62292
62293   arg1 = (Dali::Toolkit::Builder *)jarg1;
62294   if (!jarg2) {
62295     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62296     return 0;
62297   }
62298   std::string arg2_str(jarg2);
62299   arg2 = &arg2_str;
62300   arg3 = (Dali::Handle *)jarg3;
62301   if (!arg3) {
62302     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
62303     return 0;
62304   }
62305   {
62306     try {
62307       result = (bool)(arg1)->ApplyStyle((std::string const &)*arg2,*arg3);
62308     } catch (std::out_of_range& e) {
62309       {
62310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62311       };
62312     } catch (std::exception& e) {
62313       {
62314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62315       };
62316     } catch (Dali::DaliException e) {
62317       {
62318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62319       };
62320     } catch (...) {
62321       {
62322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62323       };
62324     }
62325   }
62326
62327   jresult = result;
62328
62329   //argout typemap for const std::string&
62330
62331   return jresult;
62332 }
62333
62334
62335 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyFromJson(void * jarg1, void * jarg2, char * jarg3) {
62336   unsigned int jresult ;
62337   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62338   Dali::Handle *arg2 = 0 ;
62339   std::string *arg3 = 0 ;
62340   bool result;
62341
62342   arg1 = (Dali::Toolkit::Builder *)jarg1;
62343   arg2 = (Dali::Handle *)jarg2;
62344   if (!arg2) {
62345     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
62346     return 0;
62347   }
62348   if (!jarg3) {
62349     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62350     return 0;
62351   }
62352   std::string arg3_str(jarg3);
62353   arg3 = &arg3_str;
62354   {
62355     try {
62356       result = (bool)(arg1)->ApplyFromJson(*arg2,(std::string const &)*arg3);
62357     } catch (std::out_of_range& e) {
62358       {
62359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62360       };
62361     } catch (std::exception& e) {
62362       {
62363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62364       };
62365     } catch (Dali::DaliException e) {
62366       {
62367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62368       };
62369     } catch (...) {
62370       {
62371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62372       };
62373     }
62374   }
62375
62376   jresult = result;
62377
62378   //argout typemap for const std::string&
62379
62380   return jresult;
62381 }
62382
62383
62384 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_0(void * jarg1, void * jarg2) {
62385   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62386   Dali::Actor arg2 ;
62387   Dali::Actor *argp2 ;
62388
62389   arg1 = (Dali::Toolkit::Builder *)jarg1;
62390   argp2 = (Dali::Actor *)jarg2;
62391   if (!argp2) {
62392     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62393     return ;
62394   }
62395   arg2 = *argp2;
62396   {
62397     try {
62398       (arg1)->AddActors(arg2);
62399     } catch (std::out_of_range& e) {
62400       {
62401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62402       };
62403     } catch (std::exception& e) {
62404       {
62405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62406       };
62407     } catch (Dali::DaliException e) {
62408       {
62409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62410       };
62411     } catch (...) {
62412       {
62413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62414       };
62415     }
62416   }
62417
62418 }
62419
62420
62421 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
62422   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62423   std::string *arg2 = 0 ;
62424   Dali::Actor arg3 ;
62425   Dali::Actor *argp3 ;
62426
62427   arg1 = (Dali::Toolkit::Builder *)jarg1;
62428   if (!jarg2) {
62429     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62430     return ;
62431   }
62432   std::string arg2_str(jarg2);
62433   arg2 = &arg2_str;
62434   argp3 = (Dali::Actor *)jarg3;
62435   if (!argp3) {
62436     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62437     return ;
62438   }
62439   arg3 = *argp3;
62440   {
62441     try {
62442       (arg1)->AddActors((std::string const &)*arg2,arg3);
62443     } catch (std::out_of_range& e) {
62444       {
62445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62446       };
62447     } catch (std::exception& e) {
62448       {
62449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62450       };
62451     } catch (Dali::DaliException e) {
62452       {
62453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62454       };
62455     } catch (...) {
62456       {
62457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62458       };
62459     }
62460   }
62461
62462
62463   //argout typemap for const std::string&
62464
62465 }
62466
62467
62468 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_CreateRenderTask(void * jarg1, char * jarg2) {
62469   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62470   std::string *arg2 = 0 ;
62471
62472   arg1 = (Dali::Toolkit::Builder *)jarg1;
62473   if (!jarg2) {
62474     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62475     return ;
62476   }
62477   std::string arg2_str(jarg2);
62478   arg2 = &arg2_str;
62479   {
62480     try {
62481       (arg1)->CreateRenderTask((std::string const &)*arg2);
62482     } catch (std::out_of_range& e) {
62483       {
62484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62485       };
62486     } catch (std::exception& e) {
62487       {
62488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62489       };
62490     } catch (Dali::DaliException e) {
62491       {
62492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62493       };
62494     } catch (...) {
62495       {
62496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62497       };
62498     }
62499   }
62500
62501
62502   //argout typemap for const std::string&
62503
62504 }
62505
62506
62507 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetFrameBufferImage(void * jarg1, char * jarg2) {
62508   void * jresult ;
62509   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62510   std::string *arg2 = 0 ;
62511   Dali::FrameBufferImage result;
62512
62513   arg1 = (Dali::Toolkit::Builder *)jarg1;
62514   if (!jarg2) {
62515     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62516     return 0;
62517   }
62518   std::string arg2_str(jarg2);
62519   arg2 = &arg2_str;
62520   {
62521     try {
62522       result = (arg1)->GetFrameBufferImage((std::string const &)*arg2);
62523     } catch (std::out_of_range& e) {
62524       {
62525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62526       };
62527     } catch (std::exception& e) {
62528       {
62529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62530       };
62531     } catch (Dali::DaliException e) {
62532       {
62533         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62534       };
62535     } catch (...) {
62536       {
62537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62538       };
62539     }
62540   }
62541
62542   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
62543
62544   //argout typemap for const std::string&
62545
62546   return jresult;
62547 }
62548
62549
62550 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPath(void * jarg1, char * jarg2) {
62551   void * jresult ;
62552   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62553   std::string *arg2 = 0 ;
62554   Dali::Path result;
62555
62556   arg1 = (Dali::Toolkit::Builder *)jarg1;
62557   if (!jarg2) {
62558     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62559     return 0;
62560   }
62561   std::string arg2_str(jarg2);
62562   arg2 = &arg2_str;
62563   {
62564     try {
62565       result = (arg1)->GetPath((std::string const &)*arg2);
62566     } catch (std::out_of_range& e) {
62567       {
62568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62569       };
62570     } catch (std::exception& e) {
62571       {
62572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62573       };
62574     } catch (Dali::DaliException e) {
62575       {
62576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62577       };
62578     } catch (...) {
62579       {
62580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62581       };
62582     }
62583   }
62584
62585   jresult = new Dali::Path((const Dali::Path &)result);
62586
62587   //argout typemap for const std::string&
62588
62589   return jresult;
62590 }
62591
62592
62593 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPathConstrainer(void * jarg1, char * jarg2) {
62594   void * jresult ;
62595   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62596   std::string *arg2 = 0 ;
62597   Dali::PathConstrainer result;
62598
62599   arg1 = (Dali::Toolkit::Builder *)jarg1;
62600   if (!jarg2) {
62601     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62602     return 0;
62603   }
62604   std::string arg2_str(jarg2);
62605   arg2 = &arg2_str;
62606   {
62607     try {
62608       result = (arg1)->GetPathConstrainer((std::string const &)*arg2);
62609     } catch (std::out_of_range& e) {
62610       {
62611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62612       };
62613     } catch (std::exception& e) {
62614       {
62615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62616       };
62617     } catch (Dali::DaliException e) {
62618       {
62619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62620       };
62621     } catch (...) {
62622       {
62623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62624       };
62625     }
62626   }
62627
62628   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
62629
62630   //argout typemap for const std::string&
62631
62632   return jresult;
62633 }
62634
62635
62636 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetLinearConstrainer(void * jarg1, char * jarg2) {
62637   void * jresult ;
62638   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62639   std::string *arg2 = 0 ;
62640   Dali::LinearConstrainer result;
62641
62642   arg1 = (Dali::Toolkit::Builder *)jarg1;
62643   if (!jarg2) {
62644     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62645     return 0;
62646   }
62647   std::string arg2_str(jarg2);
62648   arg2 = &arg2_str;
62649   {
62650     try {
62651       result = (arg1)->GetLinearConstrainer((std::string const &)*arg2);
62652     } catch (std::out_of_range& e) {
62653       {
62654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62655       };
62656     } catch (std::exception& e) {
62657       {
62658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62659       };
62660     } catch (Dali::DaliException e) {
62661       {
62662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62663       };
62664     } catch (...) {
62665       {
62666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62667       };
62668     }
62669   }
62670
62671   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
62672
62673   //argout typemap for const std::string&
62674
62675   return jresult;
62676 }
62677
62678
62679 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_QuitSignal(void * jarg1) {
62680   void * jresult ;
62681   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62682   Dali::Toolkit::Builder::BuilderSignalType *result = 0 ;
62683
62684   arg1 = (Dali::Toolkit::Builder *)jarg1;
62685   {
62686     try {
62687       result = (Dali::Toolkit::Builder::BuilderSignalType *) &(arg1)->QuitSignal();
62688     } catch (std::out_of_range& e) {
62689       {
62690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62691       };
62692     } catch (std::exception& e) {
62693       {
62694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62695       };
62696     } catch (Dali::DaliException e) {
62697       {
62698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62699       };
62700     } catch (...) {
62701       {
62702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62703       };
62704     }
62705   }
62706
62707   jresult = (void *)result;
62708   return jresult;
62709 }
62710
62711
62712 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_0() {
62713   void * jresult ;
62714   Dali::Toolkit::TransitionData *result = 0 ;
62715
62716   {
62717     try {
62718       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData();
62719     } catch (std::out_of_range& e) {
62720       {
62721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62722       };
62723     } catch (std::exception& e) {
62724       {
62725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62726       };
62727     } catch (Dali::DaliException e) {
62728       {
62729         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62730       };
62731     } catch (...) {
62732       {
62733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62734       };
62735     }
62736   }
62737
62738   jresult = (void *)result;
62739   return jresult;
62740 }
62741
62742 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TransitionData(void * jarg1) {
62743   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62744
62745   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62746   {
62747     try {
62748       delete arg1;
62749     } catch (std::out_of_range& e) {
62750       {
62751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62752       };
62753     } catch (std::exception& e) {
62754       {
62755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62756       };
62757     } catch (Dali::DaliException e) {
62758       {
62759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62760       };
62761     } catch (...) {
62762       {
62763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62764       };
62765     }
62766   }
62767
62768 }
62769
62770
62771 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_0(void * jarg1) {
62772   void * jresult ;
62773   Dali::Property::Map *arg1 = 0 ;
62774   Dali::Toolkit::TransitionData result;
62775
62776   arg1 = (Dali::Property::Map *)jarg1;
62777   if (!arg1) {
62778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
62779     return 0;
62780   }
62781   {
62782     try {
62783       result = Dali::Toolkit::TransitionData::New((Dali::Property::Map const &)*arg1);
62784     } catch (std::out_of_range& e) {
62785       {
62786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62787       };
62788     } catch (std::exception& e) {
62789       {
62790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62791       };
62792     } catch (Dali::DaliException e) {
62793       {
62794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62795       };
62796     } catch (...) {
62797       {
62798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62799       };
62800     }
62801   }
62802
62803   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
62804   return jresult;
62805 }
62806
62807
62808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_1(void * jarg1) {
62809   void * jresult ;
62810   Dali::Property::Array *arg1 = 0 ;
62811   Dali::Toolkit::TransitionData result;
62812
62813   arg1 = (Dali::Property::Array *)jarg1;
62814   if (!arg1) {
62815     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
62816     return 0;
62817   }
62818   {
62819     try {
62820       result = Dali::Toolkit::TransitionData::New((Dali::Property::Array const &)*arg1);
62821     } catch (std::out_of_range& e) {
62822       {
62823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62824       };
62825     } catch (std::exception& e) {
62826       {
62827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62828       };
62829     } catch (Dali::DaliException e) {
62830       {
62831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62832       };
62833     } catch (...) {
62834       {
62835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62836       };
62837     }
62838   }
62839
62840   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
62841   return jresult;
62842 }
62843
62844
62845 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_DownCast(void * jarg1) {
62846   void * jresult ;
62847   Dali::BaseHandle arg1 ;
62848   Dali::BaseHandle *argp1 ;
62849   Dali::Toolkit::TransitionData result;
62850
62851   argp1 = (Dali::BaseHandle *)jarg1;
62852   if (!argp1) {
62853     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
62854     return 0;
62855   }
62856   arg1 = *argp1;
62857   {
62858     try {
62859       result = Dali::Toolkit::TransitionData::DownCast(arg1);
62860     } catch (std::out_of_range& e) {
62861       {
62862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62863       };
62864     } catch (std::exception& e) {
62865       {
62866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62867       };
62868     } catch (Dali::DaliException e) {
62869       {
62870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62871       };
62872     } catch (...) {
62873       {
62874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62875       };
62876     }
62877   }
62878
62879   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
62880   return jresult;
62881 }
62882
62883
62884 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_1(void * jarg1) {
62885   void * jresult ;
62886   Dali::Toolkit::TransitionData *arg1 = 0 ;
62887   Dali::Toolkit::TransitionData *result = 0 ;
62888
62889   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62890   if (!arg1) {
62891     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
62892     return 0;
62893   }
62894   {
62895     try {
62896       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData((Dali::Toolkit::TransitionData const &)*arg1);
62897     } catch (std::out_of_range& e) {
62898       {
62899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62900       };
62901     } catch (std::exception& e) {
62902       {
62903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62904       };
62905     } catch (Dali::DaliException e) {
62906       {
62907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62908       };
62909     } catch (...) {
62910       {
62911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62912       };
62913     }
62914   }
62915
62916   jresult = (void *)result;
62917   return jresult;
62918 }
62919
62920
62921 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_Assign(void * jarg1, void * jarg2) {
62922   void * jresult ;
62923   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62924   Dali::Toolkit::TransitionData *arg2 = 0 ;
62925   Dali::Toolkit::TransitionData *result = 0 ;
62926
62927   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62928   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
62929   if (!arg2) {
62930     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
62931     return 0;
62932   }
62933   {
62934     try {
62935       result = (Dali::Toolkit::TransitionData *) &(arg1)->operator =((Dali::Toolkit::TransitionData const &)*arg2);
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 = (void *)result;
62956   return jresult;
62957 }
62958
62959
62960 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TransitionData_Count(void * jarg1) {
62961   unsigned long jresult ;
62962   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62963   size_t result;
62964
62965   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62966   {
62967     try {
62968       result = ((Dali::Toolkit::TransitionData const *)arg1)->Count();
62969     } catch (std::out_of_range& e) {
62970       {
62971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62972       };
62973     } catch (std::exception& e) {
62974       {
62975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62976       };
62977     } catch (Dali::DaliException e) {
62978       {
62979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62980       };
62981     } catch (...) {
62982       {
62983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62984       };
62985     }
62986   }
62987
62988   jresult = (unsigned long)result;
62989   return jresult;
62990 }
62991
62992
62993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_GetAnimatorAt(void * jarg1, unsigned long jarg2) {
62994   void * jresult ;
62995   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62996   size_t arg2 ;
62997   Dali::Property::Map result;
62998
62999   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
63000   arg2 = (size_t)jarg2;
63001   {
63002     try {
63003       result = (arg1)->GetAnimatorAt(arg2);
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 = new Dali::Property::Map((const Dali::Property::Map &)result);
63024   return jresult;
63025 }
63026
63027
63028 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_2(void * jarg1) {
63029   void * jresult ;
63030   Dali::Toolkit::Internal::TransitionData *arg1 = (Dali::Toolkit::Internal::TransitionData *) 0 ;
63031   Dali::Toolkit::TransitionData *result = 0 ;
63032
63033   arg1 = (Dali::Toolkit::Internal::TransitionData *)jarg1;
63034   {
63035     try {
63036       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData(arg1);
63037     } catch (std::out_of_range& e) {
63038       {
63039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63040       };
63041     } catch (std::exception& e) {
63042       {
63043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63044       };
63045     } catch (Dali::DaliException e) {
63046       {
63047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63048       };
63049     } catch (...) {
63050       {
63051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63052       };
63053     }
63054   }
63055
63056   jresult = (void *)result;
63057   return jresult;
63058 }
63059
63060
63061 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_CONTENT_get() {
63062   int jresult ;
63063   int result;
63064
63065   {
63066     try {
63067       result = (int)Dali::Toolkit::Tooltip::Property::CONTENT;
63068     } catch (std::out_of_range& e) {
63069       {
63070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63071       };
63072     } catch (std::exception& e) {
63073       {
63074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63075       };
63076     } catch (Dali::DaliException e) {
63077       {
63078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63079       };
63080     } catch (...) {
63081       {
63082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63083       };
63084     }
63085   }
63086
63087   jresult = (int)result;
63088   return jresult;
63089 }
63090
63091
63092 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_LAYOUT_get() {
63093   int jresult ;
63094   int result;
63095
63096   {
63097     try {
63098       result = (int)Dali::Toolkit::Tooltip::Property::LAYOUT;
63099     } catch (std::out_of_range& e) {
63100       {
63101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63102       };
63103     } catch (std::exception& e) {
63104       {
63105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63106       };
63107     } catch (Dali::DaliException e) {
63108       {
63109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63110       };
63111     } catch (...) {
63112       {
63113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63114       };
63115     }
63116   }
63117
63118   jresult = (int)result;
63119   return jresult;
63120 }
63121
63122
63123 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_WAIT_TIME_get() {
63124   int jresult ;
63125   int result;
63126
63127   {
63128     try {
63129       result = (int)Dali::Toolkit::Tooltip::Property::WAIT_TIME;
63130     } catch (std::out_of_range& e) {
63131       {
63132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63133       };
63134     } catch (std::exception& e) {
63135       {
63136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63137       };
63138     } catch (Dali::DaliException e) {
63139       {
63140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63141       };
63142     } catch (...) {
63143       {
63144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63145       };
63146     }
63147   }
63148
63149   jresult = (int)result;
63150   return jresult;
63151 }
63152
63153
63154 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_get() {
63155   int jresult ;
63156   int result;
63157
63158   {
63159     try {
63160       result = (int)Dali::Toolkit::Tooltip::Property::BACKGROUND;
63161     } catch (std::out_of_range& e) {
63162       {
63163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63164       };
63165     } catch (std::exception& e) {
63166       {
63167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63168       };
63169     } catch (Dali::DaliException e) {
63170       {
63171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63172       };
63173     } catch (...) {
63174       {
63175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63176       };
63177     }
63178   }
63179
63180   jresult = (int)result;
63181   return jresult;
63182 }
63183
63184
63185 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_get() {
63186   int jresult ;
63187   int result;
63188
63189   {
63190     try {
63191       result = (int)Dali::Toolkit::Tooltip::Property::TAIL;
63192     } catch (std::out_of_range& e) {
63193       {
63194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63195       };
63196     } catch (std::exception& e) {
63197       {
63198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63199       };
63200     } catch (Dali::DaliException e) {
63201       {
63202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63203       };
63204     } catch (...) {
63205       {
63206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63207       };
63208     }
63209   }
63210
63211   jresult = (int)result;
63212   return jresult;
63213 }
63214
63215
63216 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_POSITION_get() {
63217   int jresult ;
63218   int result;
63219
63220   {
63221     try {
63222       result = (int)Dali::Toolkit::Tooltip::Property::POSITION;
63223     } catch (std::out_of_range& e) {
63224       {
63225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63226       };
63227     } catch (std::exception& e) {
63228       {
63229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63230       };
63231     } catch (Dali::DaliException e) {
63232       {
63233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63234       };
63235     } catch (...) {
63236       {
63237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63238       };
63239     }
63240   }
63241
63242   jresult = (int)result;
63243   return jresult;
63244 }
63245
63246
63247 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_HOVER_POINT_OFFSET_get() {
63248   int jresult ;
63249   int result;
63250
63251   {
63252     try {
63253       result = (int)Dali::Toolkit::Tooltip::Property::HOVER_POINT_OFFSET;
63254     } catch (std::out_of_range& e) {
63255       {
63256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63257       };
63258     } catch (std::exception& e) {
63259       {
63260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63261       };
63262     } catch (Dali::DaliException e) {
63263       {
63264         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63265       };
63266     } catch (...) {
63267       {
63268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63269       };
63270     }
63271   }
63272
63273   jresult = (int)result;
63274   return jresult;
63275 }
63276
63277
63278 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_MOVEMENT_THRESHOLD_get() {
63279   int jresult ;
63280   int result;
63281
63282   {
63283     try {
63284       result = (int)Dali::Toolkit::Tooltip::Property::MOVEMENT_THRESHOLD;
63285     } catch (std::out_of_range& e) {
63286       {
63287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63288       };
63289     } catch (std::exception& e) {
63290       {
63291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63292       };
63293     } catch (Dali::DaliException e) {
63294       {
63295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63296       };
63297     } catch (...) {
63298       {
63299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63300       };
63301     }
63302   }
63303
63304   jresult = (int)result;
63305   return jresult;
63306 }
63307
63308
63309 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_DISAPPEAR_ON_MOVEMENT_get() {
63310   int jresult ;
63311   int result;
63312
63313   {
63314     try {
63315       result = (int)Dali::Toolkit::Tooltip::Property::DISAPPEAR_ON_MOVEMENT;
63316     } catch (std::out_of_range& e) {
63317       {
63318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63319       };
63320     } catch (std::exception& e) {
63321       {
63322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63323       };
63324     } catch (Dali::DaliException e) {
63325       {
63326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63327       };
63328     } catch (...) {
63329       {
63330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63331       };
63332     }
63333   }
63334
63335   jresult = (int)result;
63336   return jresult;
63337 }
63338
63339
63340 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_VISUAL_get() {
63341   int jresult ;
63342   int result;
63343
63344   {
63345     try {
63346       result = (int)Dali::Toolkit::Tooltip::Background::Property::VISUAL;
63347     } catch (std::out_of_range& e) {
63348       {
63349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63350       };
63351     } catch (std::exception& e) {
63352       {
63353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63354       };
63355     } catch (Dali::DaliException e) {
63356       {
63357         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63358       };
63359     } catch (...) {
63360       {
63361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63362       };
63363     }
63364   }
63365
63366   jresult = (int)result;
63367   return jresult;
63368 }
63369
63370
63371 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_BORDER_get() {
63372   int jresult ;
63373   int result;
63374
63375   {
63376     try {
63377       result = (int)Dali::Toolkit::Tooltip::Background::Property::BORDER;
63378     } catch (std::out_of_range& e) {
63379       {
63380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63381       };
63382     } catch (std::exception& e) {
63383       {
63384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63385       };
63386     } catch (Dali::DaliException e) {
63387       {
63388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63389       };
63390     } catch (...) {
63391       {
63392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63393       };
63394     }
63395   }
63396
63397   jresult = (int)result;
63398   return jresult;
63399 }
63400
63401
63402 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_VISIBILITY_get() {
63403   int jresult ;
63404   int result;
63405
63406   {
63407     try {
63408       result = (int)Dali::Toolkit::Tooltip::Tail::Property::VISIBILITY;
63409     } catch (std::out_of_range& e) {
63410       {
63411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63412       };
63413     } catch (std::exception& e) {
63414       {
63415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63416       };
63417     } catch (Dali::DaliException e) {
63418       {
63419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63420       };
63421     } catch (...) {
63422       {
63423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63424       };
63425     }
63426   }
63427
63428   jresult = (int)result;
63429   return jresult;
63430 }
63431
63432
63433 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_ABOVE_VISUAL_get() {
63434   int jresult ;
63435   int result;
63436
63437   {
63438     try {
63439       result = (int)Dali::Toolkit::Tooltip::Tail::Property::ABOVE_VISUAL;
63440     } catch (std::out_of_range& e) {
63441       {
63442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63443       };
63444     } catch (std::exception& e) {
63445       {
63446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63447       };
63448     } catch (Dali::DaliException e) {
63449       {
63450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63451       };
63452     } catch (...) {
63453       {
63454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63455       };
63456     }
63457   }
63458
63459   jresult = (int)result;
63460   return jresult;
63461 }
63462
63463
63464 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_BELOW_VISUAL_get() {
63465   int jresult ;
63466   int result;
63467
63468   {
63469     try {
63470       result = (int)Dali::Toolkit::Tooltip::Tail::Property::BELOW_VISUAL;
63471     } catch (std::out_of_range& e) {
63472       {
63473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63474       };
63475     } catch (std::exception& e) {
63476       {
63477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63478       };
63479     } catch (Dali::DaliException e) {
63480       {
63481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63482       };
63483     } catch (...) {
63484       {
63485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63486       };
63487     }
63488   }
63489
63490   jresult = (int)result;
63491   return jresult;
63492 }
63493
63494
63495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_New() {
63496   void * jresult ;
63497   Dali::Toolkit::Control result;
63498
63499   {
63500     try {
63501       result = Dali::Toolkit::Internal::Control::New();
63502     } catch (std::out_of_range& e) {
63503       {
63504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63505       };
63506     } catch (std::exception& e) {
63507       {
63508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63509       };
63510     } catch (Dali::DaliException e) {
63511       {
63512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63513       };
63514     } catch (...) {
63515       {
63516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63517       };
63518     }
63519   }
63520
63521   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
63522   return jresult;
63523 }
63524
63525
63526 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetStyleName(void * jarg1, char * jarg2) {
63527   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63528   std::string *arg2 = 0 ;
63529
63530   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63531   if (!jarg2) {
63532     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
63533     return ;
63534   }
63535   std::string arg2_str(jarg2);
63536   arg2 = &arg2_str;
63537   {
63538     try {
63539       (arg1)->SetStyleName((std::string const &)*arg2);
63540     } catch (std::out_of_range& e) {
63541       {
63542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63543       };
63544     } catch (std::exception& e) {
63545       {
63546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63547       };
63548     } catch (Dali::DaliException e) {
63549       {
63550         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63551       };
63552     } catch (...) {
63553       {
63554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63555       };
63556     }
63557   }
63558
63559
63560   //argout typemap for const std::string&
63561
63562 }
63563
63564
63565 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ViewImpl_GetStyleName(void * jarg1) {
63566   char * jresult ;
63567   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63568   std::string *result = 0 ;
63569
63570   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63571   {
63572     try {
63573       result = (std::string *) &((Dali::Toolkit::Internal::Control const *)arg1)->GetStyleName();
63574     } catch (std::out_of_range& e) {
63575       {
63576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63577       };
63578     } catch (std::exception& e) {
63579       {
63580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63581       };
63582     } catch (Dali::DaliException e) {
63583       {
63584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63585       };
63586     } catch (...) {
63587       {
63588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63589       };
63590     }
63591   }
63592
63593   jresult = SWIG_csharp_string_callback(result->c_str());
63594   return jresult;
63595 }
63596
63597
63598 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundColor(void * jarg1, void * jarg2) {
63599   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63600   Dali::Vector4 *arg2 = 0 ;
63601
63602   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63603   arg2 = (Dali::Vector4 *)jarg2;
63604   if (!arg2) {
63605     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
63606     return ;
63607   }
63608   {
63609     try {
63610       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
63611     } catch (std::out_of_range& e) {
63612       {
63613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63614       };
63615     } catch (std::exception& e) {
63616       {
63617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63618       };
63619     } catch (Dali::DaliException e) {
63620       {
63621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63622       };
63623     } catch (...) {
63624       {
63625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63626       };
63627     }
63628   }
63629
63630 }
63631
63632
63633 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetBackgroundColor(void * jarg1) {
63634   void * jresult ;
63635   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63636   Dali::Vector4 result;
63637
63638   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63639   {
63640     try {
63641       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetBackgroundColor();
63642     } catch (std::out_of_range& e) {
63643       {
63644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63645       };
63646     } catch (std::exception& e) {
63647       {
63648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63649       };
63650     } catch (Dali::DaliException e) {
63651       {
63652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63653       };
63654     } catch (...) {
63655       {
63656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63657       };
63658     }
63659   }
63660
63661   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
63662   return jresult;
63663 }
63664
63665
63666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundImage(void * jarg1, void * jarg2) {
63667   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63668   Dali::Image arg2 ;
63669   Dali::Image *argp2 ;
63670
63671   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63672   argp2 = (Dali::Image *)jarg2;
63673   if (!argp2) {
63674     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
63675     return ;
63676   }
63677   arg2 = *argp2;
63678   {
63679     try {
63680       (arg1)->SetBackgroundImage(arg2);
63681     } catch (std::out_of_range& e) {
63682       {
63683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63684       };
63685     } catch (std::exception& e) {
63686       {
63687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63688       };
63689     } catch (Dali::DaliException e) {
63690       {
63691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63692       };
63693     } catch (...) {
63694       {
63695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63696       };
63697     }
63698   }
63699
63700 }
63701
63702
63703 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackground(void * jarg1, void * jarg2) {
63704   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63705   Dali::Property::Map *arg2 = 0 ;
63706
63707   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63708   arg2 = (Dali::Property::Map *)jarg2;
63709   if (!arg2) {
63710     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
63711     return ;
63712   }
63713   {
63714     try {
63715       (arg1)->SetBackground((Dali::Property::Map const &)*arg2);
63716     } catch (std::out_of_range& e) {
63717       {
63718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63719       };
63720     } catch (std::exception& e) {
63721       {
63722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63723       };
63724     } catch (Dali::DaliException e) {
63725       {
63726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63727       };
63728     } catch (...) {
63729       {
63730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63731       };
63732     }
63733   }
63734
63735 }
63736
63737
63738 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearBackground(void * jarg1) {
63739   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63740
63741   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63742   {
63743     try {
63744       (arg1)->ClearBackground();
63745     } catch (std::out_of_range& e) {
63746       {
63747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63748       };
63749     } catch (std::exception& e) {
63750       {
63751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63752       };
63753     } catch (Dali::DaliException e) {
63754       {
63755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63756       };
63757     } catch (...) {
63758       {
63759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63760       };
63761     }
63762   }
63763
63764 }
63765
63766
63767 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_EnableGestureDetection(void * jarg1, int jarg2) {
63768   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63769   Dali::Gesture::Type arg2 ;
63770
63771   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63772   arg2 = (Dali::Gesture::Type)jarg2;
63773   {
63774     try {
63775       (arg1)->EnableGestureDetection(arg2);
63776     } catch (std::out_of_range& e) {
63777       {
63778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63779       };
63780     } catch (std::exception& e) {
63781       {
63782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63783       };
63784     } catch (Dali::DaliException e) {
63785       {
63786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63787       };
63788     } catch (...) {
63789       {
63790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63791       };
63792     }
63793   }
63794
63795 }
63796
63797
63798 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_DisableGestureDetection(void * jarg1, int jarg2) {
63799   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63800   Dali::Gesture::Type arg2 ;
63801
63802   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63803   arg2 = (Dali::Gesture::Type)jarg2;
63804   {
63805     try {
63806       (arg1)->DisableGestureDetection(arg2);
63807     } catch (std::out_of_range& e) {
63808       {
63809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63810       };
63811     } catch (std::exception& e) {
63812       {
63813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63814       };
63815     } catch (Dali::DaliException e) {
63816       {
63817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63818       };
63819     } catch (...) {
63820       {
63821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63822       };
63823     }
63824   }
63825
63826 }
63827
63828
63829 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPinchGestureDetector(void * jarg1) {
63830   void * jresult ;
63831   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63832   Dali::PinchGestureDetector result;
63833
63834   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63835   {
63836     try {
63837       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPinchGestureDetector();
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::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
63858   return jresult;
63859 }
63860
63861
63862 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPanGestureDetector(void * jarg1) {
63863   void * jresult ;
63864   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63865   Dali::PanGestureDetector result;
63866
63867   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63868   {
63869     try {
63870       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPanGestureDetector();
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::PanGestureDetector((const Dali::PanGestureDetector &)result);
63891   return jresult;
63892 }
63893
63894
63895 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetTapGestureDetector(void * jarg1) {
63896   void * jresult ;
63897   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63898   Dali::TapGestureDetector result;
63899
63900   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63901   {
63902     try {
63903       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetTapGestureDetector();
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::TapGestureDetector((const Dali::TapGestureDetector &)result);
63924   return jresult;
63925 }
63926
63927
63928 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetLongPressGestureDetector(void * jarg1) {
63929   void * jresult ;
63930   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63931   Dali::LongPressGestureDetector result;
63932
63933   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63934   {
63935     try {
63936       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetLongPressGestureDetector();
63937     } catch (std::out_of_range& e) {
63938       {
63939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63940       };
63941     } catch (std::exception& e) {
63942       {
63943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63944       };
63945     } catch (Dali::DaliException e) {
63946       {
63947         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63948       };
63949     } catch (...) {
63950       {
63951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63952       };
63953     }
63954   }
63955
63956   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
63957   return jresult;
63958 }
63959
63960
63961 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyboardNavigationSupport(void * jarg1, unsigned int jarg2) {
63962   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63963   bool arg2 ;
63964
63965   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63966   arg2 = jarg2 ? true : false;
63967   {
63968     try {
63969       (arg1)->SetKeyboardNavigationSupport(arg2);
63970     } catch (std::out_of_range& e) {
63971       {
63972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63973       };
63974     } catch (std::exception& e) {
63975       {
63976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63977       };
63978     } catch (Dali::DaliException e) {
63979       {
63980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63981       };
63982     } catch (...) {
63983       {
63984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63985       };
63986     }
63987   }
63988
63989 }
63990
63991
63992 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardNavigationSupported(void * jarg1) {
63993   unsigned int jresult ;
63994   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63995   bool result;
63996
63997   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63998   {
63999     try {
64000       result = (bool)(arg1)->IsKeyboardNavigationSupported();
64001     } catch (std::out_of_range& e) {
64002       {
64003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64004       };
64005     } catch (std::exception& e) {
64006       {
64007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64008       };
64009     } catch (Dali::DaliException e) {
64010       {
64011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64012       };
64013     } catch (...) {
64014       {
64015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64016       };
64017     }
64018   }
64019
64020   jresult = result;
64021   return jresult;
64022 }
64023
64024
64025 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyInputFocus(void * jarg1) {
64026   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64027
64028   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64029   {
64030     try {
64031       (arg1)->SetKeyInputFocus();
64032     } catch (std::out_of_range& e) {
64033       {
64034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64035       };
64036     } catch (std::exception& e) {
64037       {
64038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64039       };
64040     } catch (Dali::DaliException e) {
64041       {
64042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64043       };
64044     } catch (...) {
64045       {
64046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64047       };
64048     }
64049   }
64050
64051 }
64052
64053
64054 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_HasKeyInputFocus(void * jarg1) {
64055   unsigned int jresult ;
64056   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64057   bool result;
64058
64059   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64060   {
64061     try {
64062       result = (bool)(arg1)->HasKeyInputFocus();
64063     } catch (std::out_of_range& e) {
64064       {
64065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64066       };
64067     } catch (std::exception& e) {
64068       {
64069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64070       };
64071     } catch (Dali::DaliException e) {
64072       {
64073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64074       };
64075     } catch (...) {
64076       {
64077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64078       };
64079     }
64080   }
64081
64082   jresult = result;
64083   return jresult;
64084 }
64085
64086
64087 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearKeyInputFocus(void * jarg1) {
64088   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64089
64090   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64091   {
64092     try {
64093       (arg1)->ClearKeyInputFocus();
64094     } catch (std::out_of_range& e) {
64095       {
64096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64097       };
64098     } catch (std::exception& e) {
64099       {
64100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64101       };
64102     } catch (Dali::DaliException e) {
64103       {
64104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64105       };
64106     } catch (...) {
64107       {
64108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64109       };
64110     }
64111   }
64112
64113 }
64114
64115
64116 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetAsKeyboardFocusGroup(void * jarg1, unsigned int jarg2) {
64117   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64118   bool arg2 ;
64119
64120   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64121   arg2 = jarg2 ? true : false;
64122   {
64123     try {
64124       (arg1)->SetAsKeyboardFocusGroup(arg2);
64125     } catch (std::out_of_range& e) {
64126       {
64127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64128       };
64129     } catch (std::exception& e) {
64130       {
64131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64132       };
64133     } catch (Dali::DaliException e) {
64134       {
64135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64136       };
64137     } catch (...) {
64138       {
64139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64140       };
64141     }
64142   }
64143
64144 }
64145
64146
64147 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardFocusGroup(void * jarg1) {
64148   unsigned int jresult ;
64149   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64150   bool result;
64151
64152   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64153   {
64154     try {
64155       result = (bool)(arg1)->IsKeyboardFocusGroup();
64156     } catch (std::out_of_range& e) {
64157       {
64158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64159       };
64160     } catch (std::exception& e) {
64161       {
64162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64163       };
64164     } catch (Dali::DaliException e) {
64165       {
64166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64167       };
64168     } catch (...) {
64169       {
64170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64171       };
64172     }
64173   }
64174
64175   jresult = result;
64176   return jresult;
64177 }
64178
64179
64180 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_AccessibilityActivate(void * jarg1) {
64181   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64182
64183   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64184   {
64185     try {
64186       (arg1)->AccessibilityActivate();
64187     } catch (std::out_of_range& e) {
64188       {
64189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64190       };
64191     } catch (std::exception& e) {
64192       {
64193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64194       };
64195     } catch (Dali::DaliException e) {
64196       {
64197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64198       };
64199     } catch (...) {
64200       {
64201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64202       };
64203     }
64204   }
64205
64206 }
64207
64208
64209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_KeyboardEnter(void * jarg1) {
64210   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64211
64212   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64213   {
64214     try {
64215       (arg1)->KeyboardEnter();
64216     } catch (std::out_of_range& e) {
64217       {
64218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64219       };
64220     } catch (std::exception& e) {
64221       {
64222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64223       };
64224     } catch (Dali::DaliException e) {
64225       {
64226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64227       };
64228     } catch (...) {
64229       {
64230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64231       };
64232     }
64233   }
64234
64235 }
64236
64237
64238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyEventSignal(void * jarg1) {
64239   void * jresult ;
64240   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64241   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
64242
64243   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64244   {
64245     try {
64246       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
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_KeyInputFocusGainedSignal(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)->KeyInputFocusGainedSignal();
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 void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusLostSignal(void * jarg1) {
64305   void * jresult ;
64306   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64307   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
64308
64309   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64310   {
64311     try {
64312       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
64313     } catch (std::out_of_range& e) {
64314       {
64315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64316       };
64317     } catch (std::exception& e) {
64318       {
64319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64320       };
64321     } catch (Dali::DaliException e) {
64322       {
64323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64324       };
64325     } catch (...) {
64326       {
64327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64328       };
64329     }
64330   }
64331
64332   jresult = (void *)result;
64333   return jresult;
64334 }
64335
64336
64337 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_EmitKeyEventSignal(void * jarg1, void * jarg2) {
64338   unsigned int jresult ;
64339   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64340   Dali::KeyEvent *arg2 = 0 ;
64341   bool result;
64342
64343   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64344   arg2 = (Dali::KeyEvent *)jarg2;
64345   if (!arg2) {
64346     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
64347     return 0;
64348   }
64349   {
64350     try {
64351       result = (bool)(arg1)->EmitKeyEventSignal((Dali::KeyEvent const &)*arg2);
64352     } catch (std::out_of_range& e) {
64353       {
64354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64355       };
64356     } catch (std::exception& e) {
64357       {
64358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64359       };
64360     } catch (Dali::DaliException e) {
64361       {
64362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64363       };
64364     } catch (...) {
64365       {
64366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64367       };
64368     }
64369   }
64370
64371   jresult = result;
64372   return jresult;
64373 }
64374
64375
64376 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnection(void * jarg1, int jarg2) {
64377   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64378   int arg2 ;
64379   SwigDirector_ViewImpl *darg = 0;
64380
64381   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64382   arg2 = (int)jarg2;
64383   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64384   if(!darg) {
64385     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64386     return;
64387   }
64388   {
64389     try {
64390       if(darg) {
64391         (darg)->OnStageConnection(arg2);
64392       }
64393     } catch (std::out_of_range& e) {
64394       {
64395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64396       };
64397     } catch (std::exception& e) {
64398       {
64399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64400       };
64401     } catch (Dali::DaliException e) {
64402       {
64403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64404       };
64405     } catch (...) {
64406       {
64407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64408       };
64409     }
64410   }
64411
64412 }
64413
64414
64415 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnectionSwigExplicitViewImpl(void * jarg1, int jarg2) {
64416   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64417   int arg2 ;
64418   SwigDirector_ViewImpl *darg = 0;
64419
64420   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64421   arg2 = (int)jarg2;
64422   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64423   if(!darg) {
64424     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64425     return;
64426   }
64427   {
64428     try {
64429       if(darg) {
64430         (darg)->OnStageConnectionSwigPublic(arg2);
64431       }
64432     } catch (std::out_of_range& e) {
64433       {
64434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64435       };
64436     } catch (std::exception& e) {
64437       {
64438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64439       };
64440     } catch (Dali::DaliException e) {
64441       {
64442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64443       };
64444     } catch (...) {
64445       {
64446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64447       };
64448     }
64449   }
64450
64451 }
64452
64453
64454 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnection(void * jarg1) {
64455   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64456   SwigDirector_ViewImpl *darg = 0;
64457
64458   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64459   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64460   if(!darg) {
64461     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64462     return;
64463   }
64464   {
64465     try {
64466       if(darg) {
64467         (darg)->OnStageDisconnection();
64468       }
64469     } catch (std::out_of_range& e) {
64470       {
64471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64472       };
64473     } catch (std::exception& e) {
64474       {
64475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64476       };
64477     } catch (Dali::DaliException e) {
64478       {
64479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64480       };
64481     } catch (...) {
64482       {
64483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64484       };
64485     }
64486   }
64487
64488 }
64489
64490
64491 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnectionSwigExplicitViewImpl(void * jarg1) {
64492   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64493   SwigDirector_ViewImpl *darg = 0;
64494
64495   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64496   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64497   if(!darg) {
64498     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64499     return;
64500   }
64501   {
64502     try {
64503       if(darg) {
64504         (darg)->OnStageDisconnectionSwigPublic();
64505       }
64506     } catch (std::out_of_range& e) {
64507       {
64508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64509       };
64510     } catch (std::exception& e) {
64511       {
64512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64513       };
64514     } catch (Dali::DaliException e) {
64515       {
64516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64517       };
64518     } catch (...) {
64519       {
64520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64521       };
64522     }
64523   }
64524
64525 }
64526
64527
64528 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAdd(void * jarg1, void * jarg2) {
64529   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64530   Dali::Actor *arg2 = 0 ;
64531   SwigDirector_ViewImpl *darg = 0;
64532
64533   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64534   arg2 = (Dali::Actor *)jarg2;
64535   if (!arg2) {
64536     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
64537     return ;
64538   }
64539   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64540   if(!darg) {
64541     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64542     return;
64543   }
64544   {
64545     try {
64546       if(darg) {
64547         (darg)->OnChildAdd(*arg2);
64548       }
64549     } catch (std::out_of_range& e) {
64550       {
64551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64552       };
64553     } catch (std::exception& e) {
64554       {
64555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64556       };
64557     } catch (Dali::DaliException e) {
64558       {
64559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64560       };
64561     } catch (...) {
64562       {
64563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64564       };
64565     }
64566   }
64567
64568 }
64569
64570
64571 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64572   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64573   Dali::Actor *arg2 = 0 ;
64574   SwigDirector_ViewImpl *darg = 0;
64575
64576   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64577   arg2 = (Dali::Actor *)jarg2;
64578   if (!arg2) {
64579     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
64580     return ;
64581   }
64582   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64583   if(!darg) {
64584     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64585     return;
64586   }
64587   {
64588     try {
64589       if(darg) {
64590           (darg)->OnChildAddSwigPublic(*arg2);
64591       }
64592     } catch (std::out_of_range& e) {
64593       {
64594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64595       };
64596     } catch (std::exception& e) {
64597       {
64598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64599       };
64600     } catch (Dali::DaliException e) {
64601       {
64602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64603       };
64604     } catch (...) {
64605       {
64606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64607       };
64608     }
64609   }
64610
64611 }
64612
64613
64614 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemove(void * jarg1, void * jarg2) {
64615   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64616   Dali::Actor *arg2 = 0 ;
64617   SwigDirector_ViewImpl *darg = 0;
64618
64619   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64620   arg2 = (Dali::Actor *)jarg2;
64621   if (!arg2) {
64622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
64623     return ;
64624   }
64625   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64626   if(!darg) {
64627     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64628     return;
64629   }
64630   {
64631     try {
64632       if(darg) {
64633         (darg)->OnChildRemove(*arg2);
64634       }
64635     } catch (std::out_of_range& e) {
64636       {
64637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64638       };
64639     } catch (std::exception& e) {
64640       {
64641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64642       };
64643     } catch (Dali::DaliException e) {
64644       {
64645         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64646       };
64647     } catch (...) {
64648       {
64649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64650       };
64651     }
64652   }
64653
64654 }
64655
64656
64657 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64658   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64659   Dali::Actor *arg2 = 0 ;
64660   SwigDirector_ViewImpl *darg = 0;
64661
64662   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64663   arg2 = (Dali::Actor *)jarg2;
64664   if (!arg2) {
64665     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
64666     return ;
64667   }
64668   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64669   if(!darg) {
64670     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64671     return;
64672   }
64673   {
64674     try {
64675       if(darg) {
64676         (darg)->OnChildRemoveSwigPublic(*arg2);
64677       }
64678     } catch (std::out_of_range& e) {
64679       {
64680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64681       };
64682     } catch (std::exception& e) {
64683       {
64684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64685       };
64686     } catch (Dali::DaliException e) {
64687       {
64688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64689       };
64690     } catch (...) {
64691       {
64692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64693       };
64694     }
64695   }
64696
64697 }
64698
64699
64700 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
64701   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64702   Dali::Property::Index arg2 ;
64703   Dali::Property::Value arg3 ;
64704   Dali::Property::Value *argp3 ;
64705   SwigDirector_ViewImpl *darg = 0;
64706
64707   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64708   arg2 = (Dali::Property::Index)jarg2;
64709   argp3 = (Dali::Property::Value *)jarg3;
64710   if (!argp3) {
64711     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
64712     return ;
64713   }
64714   arg3 = *argp3;
64715   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64716   if (!darg) {
64717     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64718     return;
64719   }
64720   {
64721     try {
64722       (darg)->OnPropertySet(arg2,arg3);
64723     } catch (std::out_of_range& e) {
64724       {
64725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64726       };
64727     } catch (std::exception& e) {
64728       {
64729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64730       };
64731     } catch (Dali::DaliException e) {
64732       {
64733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64734       };
64735     } catch (...) {
64736       {
64737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64738       };
64739     }
64740   }
64741
64742 }
64743
64744
64745 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySetSwigExplicitViewImpl(void * jarg1, int jarg2, void * jarg3) {
64746   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64747   Dali::Property::Index arg2 ;
64748   Dali::Property::Value arg3 ;
64749   Dali::Property::Value *argp3 ;
64750   SwigDirector_ViewImpl *darg = 0;
64751
64752   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64753   arg2 = (Dali::Property::Index)jarg2;
64754   argp3 = (Dali::Property::Value *)jarg3;
64755   if (!argp3) {
64756     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
64757     return ;
64758   }
64759   arg3 = *argp3;
64760   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64761   if (!darg) {
64762     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64763     return;
64764   }
64765   {
64766     try {
64767       (darg)->OnPropertySetSwigPublic(arg2,arg3);
64768     } catch (std::out_of_range& e) {
64769       {
64770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64771       };
64772     } catch (std::exception& e) {
64773       {
64774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64775       };
64776     } catch (Dali::DaliException e) {
64777       {
64778         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64779       };
64780     } catch (...) {
64781       {
64782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64783       };
64784     }
64785   }
64786
64787 }
64788
64789
64790 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSet(void * jarg1, void * jarg2) {
64791   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64792   Dali::Vector3 *arg2 = 0 ;
64793   SwigDirector_ViewImpl *darg = 0;
64794
64795   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64796   arg2 = (Dali::Vector3 *)jarg2;
64797   if (!arg2) {
64798     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64799     return ;
64800   }
64801   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64802   if (!darg) {
64803     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64804     return;
64805   }
64806   {
64807     try {
64808       (darg)->OnSizeSet((Dali::Vector3 const &)*arg2);
64809     } catch (std::out_of_range& e) {
64810       {
64811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64812       };
64813     } catch (std::exception& e) {
64814       {
64815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64816       };
64817     } catch (Dali::DaliException e) {
64818       {
64819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64820       };
64821     } catch (...) {
64822       {
64823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64824       };
64825     }
64826   }
64827
64828 }
64829
64830
64831 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSetSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64832   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64833   Dali::Vector3 *arg2 = 0 ;
64834   SwigDirector_ViewImpl *darg = 0;
64835
64836   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64837   arg2 = (Dali::Vector3 *)jarg2;
64838   if (!arg2) {
64839     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64840     return ;
64841   }
64842   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64843   if (!darg) {
64844     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64845     return;
64846   }
64847   {
64848     try {
64849       (darg)->OnSizeSetSwigPublic((Dali::Vector3 const &)*arg2);
64850     } catch (std::out_of_range& e) {
64851       {
64852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64853       };
64854     } catch (std::exception& e) {
64855       {
64856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64857       };
64858     } catch (Dali::DaliException e) {
64859       {
64860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64861       };
64862     } catch (...) {
64863       {
64864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64865       };
64866     }
64867   }
64868
64869 }
64870
64871
64872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
64873   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64874   Dali::Animation *arg2 = 0 ;
64875   Dali::Vector3 *arg3 = 0 ;
64876   SwigDirector_ViewImpl *darg = 0;
64877
64878   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64879   arg2 = (Dali::Animation *)jarg2;
64880   if (!arg2) {
64881     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
64882     return ;
64883   }
64884   arg3 = (Dali::Vector3 *)jarg3;
64885   if (!arg3) {
64886     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64887     return ;
64888   }
64889   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64890   if (!darg) {
64891     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64892     return;
64893   }
64894   {
64895     try {
64896       (darg)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
64897     } catch (std::out_of_range& e) {
64898       {
64899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64900       };
64901     } catch (std::exception& e) {
64902       {
64903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64904       };
64905     } catch (Dali::DaliException e) {
64906       {
64907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64908       };
64909     } catch (...) {
64910       {
64911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64912       };
64913     }
64914   }
64915
64916 }
64917
64918
64919 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimationSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
64920   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64921   Dali::Animation *arg2 = 0 ;
64922   Dali::Vector3 *arg3 = 0 ;
64923   SwigDirector_ViewImpl *darg = 0;
64924
64925   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64926   arg2 = (Dali::Animation *)jarg2;
64927   if (!arg2) {
64928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
64929     return ;
64930   }
64931   arg3 = (Dali::Vector3 *)jarg3;
64932   if (!arg3) {
64933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64934     return ;
64935   }
64936   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64937   if (!darg) {
64938     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64939     return;
64940   }
64941   {
64942     try {
64943       (darg)->OnSizeAnimationSwigPublic(*arg2,(Dali::Vector3 const &)*arg3);
64944     } catch (std::out_of_range& e) {
64945       {
64946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64947       };
64948     } catch (std::exception& e) {
64949       {
64950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64951       };
64952     } catch (Dali::DaliException e) {
64953       {
64954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64955       };
64956     } catch (...) {
64957       {
64958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64959       };
64960     }
64961   }
64962
64963 }
64964
64965
64966 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEvent(void * jarg1, void * jarg2) {
64967   unsigned int jresult ;
64968   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64969   Dali::TouchEvent *arg2 = 0 ;
64970   SwigDirector_ViewImpl *darg = 0;
64971   bool result;
64972
64973   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64974   arg2 = (Dali::TouchEvent *)jarg2;
64975   if (!arg2) {
64976     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
64977     return 0;
64978   }
64979   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64980   if (!darg) {
64981     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64982     return 0;
64983   }
64984   {
64985     try {
64986       result = (bool)(darg)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
64987     } catch (std::out_of_range& e) {
64988       {
64989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64990       };
64991     } catch (std::exception& e) {
64992       {
64993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64994       };
64995     } catch (Dali::DaliException e) {
64996       {
64997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64998       };
64999     } catch (...) {
65000       {
65001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65002       };
65003     }
65004   }
65005
65006   jresult = result;
65007   return jresult;
65008 }
65009
65010
65011 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
65012   unsigned int jresult ;
65013   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65014   Dali::TouchEvent *arg2 = 0 ;
65015   SwigDirector_ViewImpl *darg = 0;
65016   bool result;
65017
65018   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65019   arg2 = (Dali::TouchEvent *)jarg2;
65020   if (!arg2) {
65021     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
65022     return 0;
65023   }
65024   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65025   if (!darg) {
65026     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65027     return 0;
65028   }
65029   {
65030     try {
65031       result = (bool)(darg)->OnTouchEventSwigPublic((Dali::TouchEvent const &)*arg2);
65032     } catch (std::out_of_range& e) {
65033       {
65034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65035       };
65036     } catch (std::exception& e) {
65037       {
65038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65039       };
65040     } catch (Dali::DaliException e) {
65041       {
65042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65043       };
65044     } catch (...) {
65045       {
65046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65047       };
65048     }
65049   }
65050
65051   jresult = result;
65052   return jresult;
65053 }
65054
65055
65056 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEvent(void * jarg1, void * jarg2) {
65057   unsigned int jresult ;
65058   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65059   Dali::HoverEvent *arg2 = 0 ;
65060   SwigDirector_ViewImpl *darg = 0;
65061   bool result;
65062
65063   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65064   arg2 = (Dali::HoverEvent *)jarg2;
65065   if (!arg2) {
65066     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
65067     return 0;
65068   }
65069   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65070   if (!darg) {
65071     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65072     return 0;
65073   }
65074   {
65075     try {
65076       result = (bool)(darg)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
65077     } catch (std::out_of_range& e) {
65078       {
65079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65080       };
65081     } catch (std::exception& e) {
65082       {
65083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65084       };
65085     } catch (Dali::DaliException e) {
65086       {
65087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65088       };
65089     } catch (...) {
65090       {
65091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65092       };
65093     }
65094   }
65095
65096   jresult = result;
65097   return jresult;
65098 }
65099
65100
65101 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
65102   unsigned int jresult ;
65103   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65104   Dali::HoverEvent *arg2 = 0 ;
65105   SwigDirector_ViewImpl *darg = 0;
65106   bool result;
65107
65108   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65109   arg2 = (Dali::HoverEvent *)jarg2;
65110   if (!arg2) {
65111     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
65112     return 0;
65113   }
65114   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65115   if (!darg) {
65116     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65117     return 0;
65118   }
65119   {
65120     try {
65121       result = (bool)(darg)->OnHoverEventSwigPublic((Dali::HoverEvent const &)*arg2);
65122     } catch (std::out_of_range& e) {
65123       {
65124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65125       };
65126     } catch (std::exception& e) {
65127       {
65128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65129       };
65130     } catch (Dali::DaliException e) {
65131       {
65132         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65133       };
65134     } catch (...) {
65135       {
65136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65137       };
65138     }
65139   }
65140
65141   jresult = result;
65142   return jresult;
65143 }
65144
65145
65146 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEvent(void * jarg1, void * jarg2) {
65147   unsigned int jresult ;
65148   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65149   Dali::KeyEvent *arg2 = 0 ;
65150   SwigDirector_ViewImpl *darg = 0;
65151   bool result;
65152
65153   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65154   arg2 = (Dali::KeyEvent *)jarg2;
65155   if (!arg2) {
65156     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
65157     return 0;
65158   }
65159   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65160   if (!darg) {
65161     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65162     return 0;
65163   }
65164   {
65165     try {
65166       result = (bool)(darg)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
65167     } catch (std::out_of_range& e) {
65168       {
65169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65170       };
65171     } catch (std::exception& e) {
65172       {
65173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65174       };
65175     } catch (Dali::DaliException e) {
65176       {
65177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65178       };
65179     } catch (...) {
65180       {
65181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65182       };
65183     }
65184   }
65185
65186   jresult = result;
65187   return jresult;
65188 }
65189
65190
65191 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
65192   unsigned int jresult ;
65193   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65194   Dali::KeyEvent *arg2 = 0 ;
65195   SwigDirector_ViewImpl *darg = 0;
65196   bool result;
65197
65198   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65199   arg2 = (Dali::KeyEvent *)jarg2;
65200   if (!arg2) {
65201     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
65202     return 0;
65203   }
65204   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65205   if (!darg) {
65206     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65207     return 0;
65208   }
65209   {
65210     try {
65211       result = (bool)(darg)->OnKeyEventSwigPublic((Dali::KeyEvent const &)*arg2);
65212     } catch (std::out_of_range& e) {
65213       {
65214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65215       };
65216     } catch (std::exception& e) {
65217       {
65218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65219       };
65220     } catch (Dali::DaliException e) {
65221       {
65222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65223       };
65224     } catch (...) {
65225       {
65226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65227       };
65228     }
65229   }
65230
65231   jresult = result;
65232   return jresult;
65233 }
65234
65235
65236 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEvent(void * jarg1, void * jarg2) {
65237   unsigned int jresult ;
65238   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65239   Dali::WheelEvent *arg2 = 0 ;
65240   SwigDirector_ViewImpl *darg = 0;
65241   bool result;
65242
65243   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65244   arg2 = (Dali::WheelEvent *)jarg2;
65245   if (!arg2) {
65246     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
65247     return 0;
65248   }
65249   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65250   if (!darg) {
65251     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65252     return 0;
65253   }
65254   {
65255     try {
65256       result = (bool)(darg)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
65257     } catch (std::out_of_range& e) {
65258       {
65259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65260       };
65261     } catch (std::exception& e) {
65262       {
65263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65264       };
65265     } catch (Dali::DaliException e) {
65266       {
65267         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65268       };
65269     } catch (...) {
65270       {
65271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65272       };
65273     }
65274   }
65275
65276   jresult = result;
65277   return jresult;
65278 }
65279
65280
65281 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
65282   unsigned int jresult ;
65283   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65284   Dali::WheelEvent *arg2 = 0 ;
65285   SwigDirector_ViewImpl *darg = 0;
65286   bool result;
65287
65288   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65289   arg2 = (Dali::WheelEvent *)jarg2;
65290   if (!arg2) {
65291     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
65292     return 0;
65293   }
65294   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65295   if (!darg) {
65296     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65297     return 0;
65298   }
65299   {
65300     try {
65301       result = (bool)(darg)->OnWheelEventSwigPublic((Dali::WheelEvent const &)*arg2);
65302     } catch (std::out_of_range& e) {
65303       {
65304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65305       };
65306     } catch (std::exception& e) {
65307       {
65308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65309       };
65310     } catch (Dali::DaliException e) {
65311       {
65312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65313       };
65314     } catch (...) {
65315       {
65316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65317       };
65318     }
65319   }
65320
65321   jresult = result;
65322   return jresult;
65323 }
65324
65325
65326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
65327   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65328   Dali::Vector2 *arg2 = 0 ;
65329   Dali::RelayoutContainer *arg3 = 0 ;
65330   SwigDirector_ViewImpl *darg = 0;
65331
65332   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65333   arg2 = (Dali::Vector2 *)jarg2;
65334   if (!arg2) {
65335     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
65336     return ;
65337   }
65338   arg3 = (Dali::RelayoutContainer *)jarg3;
65339   if (!arg3) {
65340     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
65341     return ;
65342   }
65343   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65344   if (!darg) {
65345     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65346     return;
65347   }
65348   {
65349     try {
65350       (darg)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
65351     } catch (std::out_of_range& e) {
65352       {
65353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65354       };
65355     } catch (std::exception& e) {
65356       {
65357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65358       };
65359     } catch (Dali::DaliException e) {
65360       {
65361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65362       };
65363     } catch (...) {
65364       {
65365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65366       };
65367     }
65368   }
65369
65370 }
65371
65372
65373 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayoutSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
65374   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65375   Dali::Vector2 *arg2 = 0 ;
65376   Dali::RelayoutContainer *arg3 = 0 ;
65377   SwigDirector_ViewImpl *darg = 0;
65378
65379   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65380   arg2 = (Dali::Vector2 *)jarg2;
65381   if (!arg2) {
65382     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
65383     return ;
65384   }
65385   arg3 = (Dali::RelayoutContainer *)jarg3;
65386   if (!arg3) {
65387     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
65388     return ;
65389   }
65390   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65391   if (!darg) {
65392     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65393     return;
65394   }
65395   {
65396     try {
65397       (darg)->OnRelayoutSwigPublic((Dali::Vector2 const &)*arg2,*arg3);
65398     } catch (std::out_of_range& e) {
65399       {
65400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65401       };
65402     } catch (std::exception& e) {
65403       {
65404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65405       };
65406     } catch (Dali::DaliException e) {
65407       {
65408         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65409       };
65410     } catch (...) {
65411       {
65412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65413       };
65414     }
65415   }
65416
65417 }
65418
65419
65420 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
65421   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65422   Dali::ResizePolicy::Type arg2 ;
65423   Dali::Dimension::Type arg3 ;
65424   SwigDirector_ViewImpl *darg = 0;
65425
65426   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65427   arg2 = (Dali::ResizePolicy::Type)jarg2;
65428   arg3 = (Dali::Dimension::Type)jarg3;
65429   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65430   if (!darg) {
65431     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65432     return;
65433   }
65434   {
65435     try {
65436       (darg)->OnSetResizePolicy(arg2,arg3);
65437     } catch (std::out_of_range& e) {
65438       {
65439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65440       };
65441     } catch (std::exception& e) {
65442       {
65443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65444       };
65445     } catch (Dali::DaliException e) {
65446       {
65447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65448       };
65449     } catch (...) {
65450       {
65451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65452       };
65453     }
65454   }
65455
65456 }
65457
65458
65459 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicySwigExplicitViewImpl(void * jarg1, int jarg2, int jarg3) {
65460   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65461   Dali::ResizePolicy::Type arg2 ;
65462   Dali::Dimension::Type arg3 ;
65463   SwigDirector_ViewImpl *darg = 0;
65464
65465   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65466   arg2 = (Dali::ResizePolicy::Type)jarg2;
65467   arg3 = (Dali::Dimension::Type)jarg3;
65468   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65469   if (!darg) {
65470     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65471     return;
65472   }
65473   {
65474     try {
65475       (darg)->OnSetResizePolicySwigPublic(arg2,arg3);
65476     } catch (std::out_of_range& e) {
65477       {
65478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65479       };
65480     } catch (std::exception& e) {
65481       {
65482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65483       };
65484     } catch (Dali::DaliException e) {
65485       {
65486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65487       };
65488     } catch (...) {
65489       {
65490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65491       };
65492     }
65493   }
65494
65495 }
65496
65497
65498 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSize(void * jarg1) {
65499   void * jresult ;
65500   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65501   SwigDirector_ViewImpl *darg = 0;
65502   Dali::Vector3 result;
65503
65504   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65505   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65506   if (!darg) {
65507     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65508     return 0;
65509   }
65510   {
65511     try {
65512       result = (darg)->GetNaturalSize();
65513     } catch (std::out_of_range& e) {
65514       {
65515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65516       };
65517     } catch (std::exception& e) {
65518       {
65519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65520       };
65521     } catch (Dali::DaliException e) {
65522       {
65523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65524       };
65525     } catch (...) {
65526       {
65527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65528       };
65529     }
65530   }
65531
65532   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
65533   return jresult;
65534 }
65535
65536
65537 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSizeSwigExplicitViewImpl(void * jarg1) {
65538   void * jresult ;
65539   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65540   SwigDirector_ViewImpl *darg = 0;
65541   Dali::Vector3 result;
65542
65543   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65544   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65545   if (!darg) {
65546     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65547     return 0;
65548   }
65549   {
65550     try {
65551       result = (darg)->GetNaturalSizeSwigPublic();
65552     } catch (std::out_of_range& e) {
65553       {
65554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65555       };
65556     } catch (std::exception& e) {
65557       {
65558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65559       };
65560     } catch (Dali::DaliException e) {
65561       {
65562         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65563       };
65564     } catch (...) {
65565       {
65566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65567       };
65568     }
65569   }
65570
65571   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
65572   return jresult;
65573 }
65574
65575
65576 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
65577   float jresult ;
65578   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65579   Dali::Actor *arg2 = 0 ;
65580   Dali::Dimension::Type arg3 ;
65581   SwigDirector_ViewImpl *darg = 0;
65582   float result;
65583
65584   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65585   arg2 = (Dali::Actor *)jarg2;
65586   if (!arg2) {
65587     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
65588     return 0;
65589   }
65590   arg3 = (Dali::Dimension::Type)jarg3;
65591   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65592   if (!darg) {
65593     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65594     return 0;
65595   }
65596   {
65597     try {
65598       result = (float)(darg)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
65599     } catch (std::out_of_range& e) {
65600       {
65601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65602       };
65603     } catch (std::exception& e) {
65604       {
65605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65606       };
65607     } catch (Dali::DaliException e) {
65608       {
65609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65610       };
65611     } catch (...) {
65612       {
65613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65614       };
65615     }
65616   }
65617
65618   jresult = result;
65619   return jresult;
65620 }
65621
65622
65623 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSizeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
65624   float jresult ;
65625   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65626   Dali::Actor *arg2 = 0 ;
65627   Dali::Dimension::Type arg3 ;
65628   SwigDirector_ViewImpl *darg = 0;
65629   float result;
65630
65631   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65632   arg2 = (Dali::Actor *)jarg2;
65633   if (!arg2) {
65634     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
65635     return 0;
65636   }
65637   arg3 = (Dali::Dimension::Type)jarg3;
65638   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65639   if (!darg) {
65640     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65641     return 0;
65642   }
65643   {
65644     try {
65645       result = (float)(darg)->CalculateChildSizeSwigPublic((Dali::Actor const &)*arg2,arg3);
65646     } catch (std::out_of_range& e) {
65647       {
65648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65649       };
65650     } catch (std::exception& e) {
65651       {
65652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65653       };
65654     } catch (Dali::DaliException e) {
65655       {
65656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65657       };
65658     } catch (...) {
65659       {
65660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65661       };
65662     }
65663   }
65664
65665   jresult = result;
65666   return jresult;
65667 }
65668
65669
65670 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidth(void * jarg1, float jarg2) {
65671   float jresult ;
65672   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65673   float arg2 ;
65674   SwigDirector_ViewImpl *darg = 0;
65675   float result;
65676
65677   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65678   arg2 = (float)jarg2;
65679   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65680   if (!darg) {
65681     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65682     return 0;
65683   }
65684   {
65685     try {
65686       result = (float)(darg)->GetHeightForWidth(arg2);
65687     } catch (std::out_of_range& e) {
65688       {
65689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65690       };
65691     } catch (std::exception& e) {
65692       {
65693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65694       };
65695     } catch (Dali::DaliException e) {
65696       {
65697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65698       };
65699     } catch (...) {
65700       {
65701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65702       };
65703     }
65704   }
65705
65706   jresult = result;
65707   return jresult;
65708 }
65709
65710
65711 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidthSwigExplicitViewImpl(void * jarg1, float jarg2) {
65712   float jresult ;
65713   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65714   float arg2 ;
65715   SwigDirector_ViewImpl *darg = 0;
65716   float result;
65717
65718   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65719   arg2 = (float)jarg2;
65720   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65721   if (!darg) {
65722     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65723     return 0;
65724   }
65725   {
65726     try {
65727       result = (float)(darg)->GetHeightForWidthSwigPublic(arg2);
65728     } catch (std::out_of_range& e) {
65729       {
65730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65731       };
65732     } catch (std::exception& e) {
65733       {
65734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65735       };
65736     } catch (Dali::DaliException e) {
65737       {
65738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65739       };
65740     } catch (...) {
65741       {
65742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65743       };
65744     }
65745   }
65746
65747   jresult = result;
65748   return jresult;
65749 }
65750
65751
65752 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeight(void * jarg1, float jarg2) {
65753   float jresult ;
65754   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65755   float arg2 ;
65756   SwigDirector_ViewImpl *darg = 0;
65757   float result;
65758
65759   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65760   arg2 = (float)jarg2;
65761   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65762   if (!darg) {
65763     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65764     return 0;
65765   }
65766   {
65767     try {
65768       result = (float)(darg)->GetWidthForHeight(arg2);
65769     } catch (std::out_of_range& e) {
65770       {
65771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65772       };
65773     } catch (std::exception& e) {
65774       {
65775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65776       };
65777     } catch (Dali::DaliException e) {
65778       {
65779         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65780       };
65781     } catch (...) {
65782       {
65783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65784       };
65785     }
65786   }
65787
65788   jresult = result;
65789   return jresult;
65790 }
65791
65792
65793 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeightSwigExplicitViewImpl(void * jarg1, float jarg2) {
65794   float jresult ;
65795   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65796   float arg2 ;
65797   SwigDirector_ViewImpl *darg = 0;
65798   float result;
65799
65800   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65801   arg2 = (float)jarg2;
65802   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65803   if (!darg) {
65804     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65805     return 0;
65806   }
65807   {
65808     try {
65809       result = (float)(darg)->GetWidthForHeightSwigPublic(arg2);
65810     } catch (std::out_of_range& e) {
65811       {
65812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65813       };
65814     } catch (std::exception& e) {
65815       {
65816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65817       };
65818     } catch (Dali::DaliException e) {
65819       {
65820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65821       };
65822     } catch (...) {
65823       {
65824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65825       };
65826     }
65827   }
65828
65829   jresult = result;
65830   return jresult;
65831 }
65832
65833
65834 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
65835   unsigned int jresult ;
65836   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65837   Dali::Dimension::Type arg2 ;
65838   SwigDirector_ViewImpl *darg = 0;
65839   bool result;
65840
65841   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65842   arg2 = (Dali::Dimension::Type)jarg2;
65843   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65844   if (!darg) {
65845     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65846     return 0;
65847   }
65848   {
65849     try {
65850       result = (bool)(darg)->RelayoutDependentOnChildren(arg2);
65851     } catch (std::out_of_range& e) {
65852       {
65853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65854       };
65855     } catch (std::exception& e) {
65856       {
65857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65858       };
65859     } catch (Dali::DaliException e) {
65860       {
65861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65862       };
65863     } catch (...) {
65864       {
65865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65866       };
65867     }
65868   }
65869
65870   jresult = result;
65871   return jresult;
65872 }
65873
65874
65875 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_0(void * jarg1, int jarg2) {
65876   unsigned int jresult ;
65877   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65878   Dali::Dimension::Type arg2 ;
65879   SwigDirector_ViewImpl *darg = 0;
65880   bool result;
65881
65882   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65883   arg2 = (Dali::Dimension::Type)jarg2;
65884   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65885   if (!darg) {
65886     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65887     return 0;
65888   }
65889   {
65890     try {
65891       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic(arg2);
65892     } catch (std::out_of_range& e) {
65893       {
65894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65895       };
65896     } catch (std::exception& e) {
65897       {
65898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65899       };
65900     } catch (Dali::DaliException e) {
65901       {
65902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65903       };
65904     } catch (...) {
65905       {
65906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65907       };
65908     }
65909   }
65910
65911   jresult = result;
65912   return jresult;
65913 }
65914
65915
65916 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
65917   unsigned int jresult ;
65918   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65919   SwigDirector_ViewImpl *darg = 0;
65920   bool result;
65921
65922   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65923   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65924   if (!darg) {
65925     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65926     return 0;
65927   }
65928   {
65929     try {
65930       result = (bool)(darg)->RelayoutDependentOnChildren();
65931     } catch (std::out_of_range& e) {
65932       {
65933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65934       };
65935     } catch (std::exception& e) {
65936       {
65937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65938       };
65939     } catch (Dali::DaliException e) {
65940       {
65941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65942       };
65943     } catch (...) {
65944       {
65945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65946       };
65947     }
65948   }
65949
65950   jresult = result;
65951   return jresult;
65952 }
65953
65954
65955 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_1(void * jarg1) {
65956   unsigned int jresult ;
65957   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65958   SwigDirector_ViewImpl *darg = 0;
65959   bool result;
65960
65961   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65962   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65963   if (!darg) {
65964     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65965     return 0;
65966   }
65967   {
65968     try {
65969       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic();
65970     } catch (std::out_of_range& e) {
65971       {
65972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65973       };
65974     } catch (std::exception& e) {
65975       {
65976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65977       };
65978     } catch (Dali::DaliException e) {
65979       {
65980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65981       };
65982     } catch (...) {
65983       {
65984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65985       };
65986     }
65987   }
65988
65989   jresult = result;
65990   return jresult;
65991 }
65992
65993
65994 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
65995   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65996   Dali::Dimension::Type arg2 ;
65997   SwigDirector_ViewImpl *darg = 0;
65998
65999   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66000   arg2 = (Dali::Dimension::Type)jarg2;
66001   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
66002   if (!darg) {
66003     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
66004     return;
66005   }
66006   {
66007     try {
66008       (darg)->OnCalculateRelayoutSize(arg2);
66009     } catch (std::out_of_range& e) {
66010       {
66011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66012       };
66013     } catch (std::exception& e) {
66014       {
66015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66016       };
66017     } catch (Dali::DaliException e) {
66018       {
66019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66020       };
66021     } catch (...) {
66022       {
66023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66024       };
66025     }
66026   }
66027
66028 }
66029
66030
66031 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSizeSwigExplicitViewImpl(void * jarg1, int jarg2) {
66032   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66033   Dali::Dimension::Type arg2 ;
66034   SwigDirector_ViewImpl *darg = 0;
66035
66036   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66037   arg2 = (Dali::Dimension::Type)jarg2;
66038   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
66039   if (!darg) {
66040     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
66041     return;
66042   }
66043   {
66044     try {
66045       (darg)->OnCalculateRelayoutSizeSwigPublic(arg2);
66046     } catch (std::out_of_range& e) {
66047       {
66048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66049       };
66050     } catch (std::exception& e) {
66051       {
66052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66053       };
66054     } catch (Dali::DaliException e) {
66055       {
66056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66057       };
66058     } catch (...) {
66059       {
66060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66061       };
66062     }
66063   }
66064
66065 }
66066
66067
66068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
66069   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66070   float arg2 ;
66071   Dali::Dimension::Type arg3 ;
66072   SwigDirector_ViewImpl *darg = 0;
66073
66074   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66075   arg2 = (float)jarg2;
66076   arg3 = (Dali::Dimension::Type)jarg3;
66077   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
66078   if (!darg) {
66079     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
66080     return;
66081   }
66082   {
66083     try {
66084       (darg)->OnLayoutNegotiated(arg2,arg3);
66085     } catch (std::out_of_range& e) {
66086       {
66087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66088       };
66089     } catch (std::exception& e) {
66090       {
66091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66092       };
66093     } catch (Dali::DaliException e) {
66094       {
66095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66096       };
66097     } catch (...) {
66098       {
66099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66100       };
66101     }
66102   }
66103
66104 }
66105
66106
66107 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiatedSwigExplicitViewImpl(void * jarg1, float jarg2, int jarg3) {
66108   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66109   float arg2 ;
66110   Dali::Dimension::Type arg3 ;
66111   SwigDirector_ViewImpl *darg = 0;
66112
66113   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66114   arg2 = (float)jarg2;
66115   arg3 = (Dali::Dimension::Type)jarg3;
66116   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
66117   if (!darg) {
66118     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
66119     return;
66120   }
66121   {
66122     try {
66123       (darg)->OnLayoutNegotiatedSwigPublic(arg2,arg3);
66124     } catch (std::out_of_range& e) {
66125       {
66126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66127       };
66128     } catch (std::exception& e) {
66129       {
66130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66131       };
66132     } catch (Dali::DaliException e) {
66133       {
66134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66135       };
66136     } catch (...) {
66137       {
66138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66139       };
66140     }
66141   }
66142
66143 }
66144
66145
66146 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitialize(void * jarg1) {
66147   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66148
66149   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66150   {
66151     try {
66152       (arg1)->OnInitialize();
66153     } catch (std::out_of_range& e) {
66154       {
66155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66156       };
66157     } catch (std::exception& e) {
66158       {
66159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66160       };
66161     } catch (Dali::DaliException e) {
66162       {
66163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66164       };
66165     } catch (...) {
66166       {
66167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66168       };
66169     }
66170   }
66171
66172 }
66173
66174
66175 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitializeSwigExplicitViewImpl(void * jarg1) {
66176   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66177
66178   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66179   {
66180     try {
66181       (arg1)->Dali::Toolkit::Internal::Control::OnInitialize();
66182     } catch (std::out_of_range& e) {
66183       {
66184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66185       };
66186     } catch (std::exception& e) {
66187       {
66188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66189       };
66190     } catch (Dali::DaliException e) {
66191       {
66192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66193       };
66194     } catch (...) {
66195       {
66196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66197       };
66198     }
66199   }
66200
66201 }
66202
66203
66204 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAdd(void * jarg1, void * jarg2) {
66205   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66206   Dali::Actor *arg2 = 0 ;
66207
66208   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66209   arg2 = (Dali::Actor *)jarg2;
66210   if (!arg2) {
66211     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
66212     return ;
66213   }
66214   {
66215     try {
66216       (arg1)->OnControlChildAdd(*arg2);
66217     } catch (std::out_of_range& e) {
66218       {
66219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66220       };
66221     } catch (std::exception& e) {
66222       {
66223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66224       };
66225     } catch (Dali::DaliException e) {
66226       {
66227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66228       };
66229     } catch (...) {
66230       {
66231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66232       };
66233     }
66234   }
66235
66236 }
66237
66238
66239 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66240   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66241   Dali::Actor *arg2 = 0 ;
66242
66243   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66244   arg2 = (Dali::Actor *)jarg2;
66245   if (!arg2) {
66246     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
66247     return ;
66248   }
66249   {
66250     try {
66251       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildAdd(*arg2);
66252     } catch (std::out_of_range& e) {
66253       {
66254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66255       };
66256     } catch (std::exception& e) {
66257       {
66258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66259       };
66260     } catch (Dali::DaliException e) {
66261       {
66262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66263       };
66264     } catch (...) {
66265       {
66266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66267       };
66268     }
66269   }
66270
66271 }
66272
66273
66274 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemove(void * jarg1, void * jarg2) {
66275   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66276   Dali::Actor *arg2 = 0 ;
66277
66278   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66279   arg2 = (Dali::Actor *)jarg2;
66280   if (!arg2) {
66281     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
66282     return ;
66283   }
66284   {
66285     try {
66286       (arg1)->OnControlChildRemove(*arg2);
66287     } catch (std::out_of_range& e) {
66288       {
66289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66290       };
66291     } catch (std::exception& e) {
66292       {
66293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66294       };
66295     } catch (Dali::DaliException e) {
66296       {
66297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66298       };
66299     } catch (...) {
66300       {
66301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66302       };
66303     }
66304   }
66305
66306 }
66307
66308
66309 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66310   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66311   Dali::Actor *arg2 = 0 ;
66312
66313   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66314   arg2 = (Dali::Actor *)jarg2;
66315   if (!arg2) {
66316     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
66317     return ;
66318   }
66319   {
66320     try {
66321       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildRemove(*arg2);
66322     } catch (std::out_of_range& e) {
66323       {
66324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66325       };
66326     } catch (std::exception& e) {
66327       {
66328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66329       };
66330     } catch (Dali::DaliException e) {
66331       {
66332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66333       };
66334     } catch (...) {
66335       {
66336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66337       };
66338     }
66339   }
66340
66341 }
66342
66343
66344 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChange(void * jarg1, void * jarg2, int jarg3) {
66345   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66346   Dali::Toolkit::StyleManager arg2 ;
66347   Dali::StyleChange::Type arg3 ;
66348   Dali::Toolkit::StyleManager *argp2 ;
66349
66350   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66351   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
66352   if (!argp2) {
66353     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
66354     return ;
66355   }
66356   arg2 = *argp2;
66357   arg3 = (Dali::StyleChange::Type)jarg3;
66358   {
66359     try {
66360       (arg1)->OnStyleChange(arg2,arg3);
66361     } catch (std::out_of_range& e) {
66362       {
66363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66364       };
66365     } catch (std::exception& e) {
66366       {
66367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66368       };
66369     } catch (Dali::DaliException e) {
66370       {
66371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66372       };
66373     } catch (...) {
66374       {
66375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66376       };
66377     }
66378   }
66379
66380 }
66381
66382
66383 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChangeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
66384   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66385   Dali::Toolkit::StyleManager arg2 ;
66386   Dali::StyleChange::Type arg3 ;
66387   Dali::Toolkit::StyleManager *argp2 ;
66388
66389   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66390   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
66391   if (!argp2) {
66392     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
66393     return ;
66394   }
66395   arg2 = *argp2;
66396   arg3 = (Dali::StyleChange::Type)jarg3;
66397   {
66398     try {
66399       (arg1)->Dali::Toolkit::Internal::Control::OnStyleChange(arg2,arg3);
66400     } catch (std::out_of_range& e) {
66401       {
66402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66403       };
66404     } catch (std::exception& e) {
66405       {
66406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66407       };
66408     } catch (Dali::DaliException e) {
66409       {
66410         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66411       };
66412     } catch (...) {
66413       {
66414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66415       };
66416     }
66417   }
66418
66419 }
66420
66421
66422 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivated(void * jarg1) {
66423   unsigned int jresult ;
66424   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66425   bool result;
66426
66427   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66428   {
66429     try {
66430       result = (bool)(arg1)->OnAccessibilityActivated();
66431     } catch (std::out_of_range& e) {
66432       {
66433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66434       };
66435     } catch (std::exception& e) {
66436       {
66437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66438       };
66439     } catch (Dali::DaliException e) {
66440       {
66441         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66442       };
66443     } catch (...) {
66444       {
66445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66446       };
66447     }
66448   }
66449
66450   jresult = result;
66451   return jresult;
66452 }
66453
66454
66455 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivatedSwigExplicitViewImpl(void * jarg1) {
66456   unsigned int jresult ;
66457   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66458   bool result;
66459
66460   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66461   {
66462     try {
66463       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
66464     } catch (std::out_of_range& e) {
66465       {
66466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66467       };
66468     } catch (std::exception& e) {
66469       {
66470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66471       };
66472     } catch (Dali::DaliException e) {
66473       {
66474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66475       };
66476     } catch (...) {
66477       {
66478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66479       };
66480     }
66481   }
66482
66483   jresult = result;
66484   return jresult;
66485 }
66486
66487
66488 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPan(void * jarg1, void * jarg2) {
66489   unsigned int jresult ;
66490   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66491   Dali::PanGesture arg2 ;
66492   Dali::PanGesture *argp2 ;
66493   bool result;
66494
66495   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66496   argp2 = (Dali::PanGesture *)jarg2;
66497   if (!argp2) {
66498     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
66499     return 0;
66500   }
66501   arg2 = *argp2;
66502   {
66503     try {
66504       result = (bool)(arg1)->OnAccessibilityPan(arg2);
66505     } catch (std::out_of_range& e) {
66506       {
66507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66508       };
66509     } catch (std::exception& e) {
66510       {
66511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66512       };
66513     } catch (Dali::DaliException e) {
66514       {
66515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66516       };
66517     } catch (...) {
66518       {
66519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66520       };
66521     }
66522   }
66523
66524   jresult = result;
66525   return jresult;
66526 }
66527
66528
66529 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66530   unsigned int jresult ;
66531   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66532   Dali::PanGesture arg2 ;
66533   Dali::PanGesture *argp2 ;
66534   bool result;
66535
66536   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66537   argp2 = (Dali::PanGesture *)jarg2;
66538   if (!argp2) {
66539     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
66540     return 0;
66541   }
66542   arg2 = *argp2;
66543   {
66544     try {
66545       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityPan(arg2);
66546     } catch (std::out_of_range& e) {
66547       {
66548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66549       };
66550     } catch (std::exception& e) {
66551       {
66552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66553       };
66554     } catch (Dali::DaliException e) {
66555       {
66556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66557       };
66558     } catch (...) {
66559       {
66560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66561       };
66562     }
66563   }
66564
66565   jresult = result;
66566   return jresult;
66567 }
66568
66569
66570 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouch(void * jarg1, void * jarg2) {
66571   unsigned int jresult ;
66572   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66573   Dali::TouchEvent *arg2 = 0 ;
66574   bool result;
66575
66576   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66577   arg2 = (Dali::TouchEvent *)jarg2;
66578   if (!arg2) {
66579     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
66580     return 0;
66581   }
66582   {
66583     try {
66584       result = (bool)(arg1)->OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
66585     } catch (std::out_of_range& e) {
66586       {
66587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66588       };
66589     } catch (std::exception& e) {
66590       {
66591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66592       };
66593     } catch (Dali::DaliException e) {
66594       {
66595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66596       };
66597     } catch (...) {
66598       {
66599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66600       };
66601     }
66602   }
66603
66604   jresult = result;
66605   return jresult;
66606 }
66607
66608
66609 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66610   unsigned int jresult ;
66611   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66612   Dali::TouchEvent *arg2 = 0 ;
66613   bool result;
66614
66615   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66616   arg2 = (Dali::TouchEvent *)jarg2;
66617   if (!arg2) {
66618     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
66619     return 0;
66620   }
66621   {
66622     try {
66623       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
66624     } catch (std::out_of_range& e) {
66625       {
66626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66627       };
66628     } catch (std::exception& e) {
66629       {
66630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66631       };
66632     } catch (Dali::DaliException e) {
66633       {
66634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66635       };
66636     } catch (...) {
66637       {
66638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66639       };
66640     }
66641   }
66642
66643   jresult = result;
66644   return jresult;
66645 }
66646
66647
66648 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChange(void * jarg1, unsigned int jarg2) {
66649   unsigned int jresult ;
66650   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66651   bool arg2 ;
66652   bool result;
66653
66654   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66655   arg2 = jarg2 ? true : false;
66656   {
66657     try {
66658       result = (bool)(arg1)->OnAccessibilityValueChange(arg2);
66659     } catch (std::out_of_range& e) {
66660       {
66661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66662       };
66663     } catch (std::exception& e) {
66664       {
66665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66666       };
66667     } catch (Dali::DaliException e) {
66668       {
66669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66670       };
66671     } catch (...) {
66672       {
66673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66674       };
66675     }
66676   }
66677
66678   jresult = result;
66679   return jresult;
66680 }
66681
66682
66683 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChangeSwigExplicitViewImpl(void * jarg1, unsigned int jarg2) {
66684   unsigned int jresult ;
66685   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66686   bool arg2 ;
66687   bool result;
66688
66689   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66690   arg2 = jarg2 ? true : false;
66691   {
66692     try {
66693       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(arg2);
66694     } catch (std::out_of_range& e) {
66695       {
66696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66697       };
66698     } catch (std::exception& e) {
66699       {
66700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66701       };
66702     } catch (Dali::DaliException e) {
66703       {
66704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66705       };
66706     } catch (...) {
66707       {
66708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66709       };
66710     }
66711   }
66712
66713   jresult = result;
66714   return jresult;
66715 }
66716
66717
66718 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoom(void * jarg1) {
66719   unsigned int jresult ;
66720   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66721   bool result;
66722
66723   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66724   {
66725     try {
66726       result = (bool)(arg1)->OnAccessibilityZoom();
66727     } catch (std::out_of_range& e) {
66728       {
66729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66730       };
66731     } catch (std::exception& e) {
66732       {
66733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66734       };
66735     } catch (Dali::DaliException e) {
66736       {
66737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66738       };
66739     } catch (...) {
66740       {
66741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66742       };
66743     }
66744   }
66745
66746   jresult = result;
66747   return jresult;
66748 }
66749
66750
66751 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoomSwigExplicitViewImpl(void * jarg1) {
66752   unsigned int jresult ;
66753   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66754   bool result;
66755
66756   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66757   {
66758     try {
66759       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
66760     } catch (std::out_of_range& e) {
66761       {
66762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66763       };
66764     } catch (std::exception& e) {
66765       {
66766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66767       };
66768     } catch (Dali::DaliException e) {
66769       {
66770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66771       };
66772     } catch (...) {
66773       {
66774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66775       };
66776     }
66777   }
66778
66779   jresult = result;
66780   return jresult;
66781 }
66782
66783
66784 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGained(void * jarg1) {
66785   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66786
66787   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66788   {
66789     try {
66790       (arg1)->OnKeyInputFocusGained();
66791     } catch (std::out_of_range& e) {
66792       {
66793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66794       };
66795     } catch (std::exception& e) {
66796       {
66797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66798       };
66799     } catch (Dali::DaliException e) {
66800       {
66801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66802       };
66803     } catch (...) {
66804       {
66805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66806       };
66807     }
66808   }
66809
66810 }
66811
66812
66813 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGainedSwigExplicitViewImpl(void * jarg1) {
66814   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66815
66816   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66817   {
66818     try {
66819       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
66820     } catch (std::out_of_range& e) {
66821       {
66822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66823       };
66824     } catch (std::exception& e) {
66825       {
66826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66827       };
66828     } catch (Dali::DaliException e) {
66829       {
66830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66831       };
66832     } catch (...) {
66833       {
66834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66835       };
66836     }
66837   }
66838
66839 }
66840
66841
66842 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLost(void * jarg1) {
66843   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66844
66845   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66846   {
66847     try {
66848       (arg1)->OnKeyInputFocusLost();
66849     } catch (std::out_of_range& e) {
66850       {
66851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66852       };
66853     } catch (std::exception& e) {
66854       {
66855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66856       };
66857     } catch (Dali::DaliException e) {
66858       {
66859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66860       };
66861     } catch (...) {
66862       {
66863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66864       };
66865     }
66866   }
66867
66868 }
66869
66870
66871 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLostSwigExplicitViewImpl(void * jarg1) {
66872   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66873
66874   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66875   {
66876     try {
66877       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
66878     } catch (std::out_of_range& e) {
66879       {
66880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66881       };
66882     } catch (std::exception& e) {
66883       {
66884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66885       };
66886     } catch (Dali::DaliException e) {
66887       {
66888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66889       };
66890     } catch (...) {
66891       {
66892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66893       };
66894     }
66895   }
66896
66897 }
66898
66899
66900 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActor(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
66901   void * jresult ;
66902   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66903   Dali::Actor arg2 ;
66904   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
66905   bool arg4 ;
66906   Dali::Actor *argp2 ;
66907   Dali::Actor result;
66908
66909   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66910   argp2 = (Dali::Actor *)jarg2;
66911   if (!argp2) {
66912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66913     return 0;
66914   }
66915   arg2 = *argp2;
66916   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
66917   arg4 = jarg4 ? true : false;
66918   {
66919     try {
66920       result = (arg1)->GetNextKeyboardFocusableActor(arg2,arg3,arg4);
66921     } catch (std::out_of_range& e) {
66922       {
66923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66924       };
66925     } catch (std::exception& e) {
66926       {
66927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66928       };
66929     } catch (Dali::DaliException e) {
66930       {
66931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66932       };
66933     } catch (...) {
66934       {
66935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66936       };
66937     }
66938   }
66939
66940   jresult = new Dali::Actor((const Dali::Actor &)result);
66941   return jresult;
66942 }
66943
66944
66945 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActorSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
66946   void * jresult ;
66947   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66948   Dali::Actor arg2 ;
66949   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
66950   bool arg4 ;
66951   Dali::Actor *argp2 ;
66952   Dali::Actor result;
66953
66954   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66955   argp2 = (Dali::Actor *)jarg2;
66956   if (!argp2) {
66957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66958     return 0;
66959   }
66960   arg2 = *argp2;
66961   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
66962   arg4 = jarg4 ? true : false;
66963   {
66964     try {
66965       result = (arg1)->Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(arg2,arg3,arg4);
66966     } catch (std::out_of_range& e) {
66967       {
66968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66969       };
66970     } catch (std::exception& e) {
66971       {
66972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66973       };
66974     } catch (Dali::DaliException e) {
66975       {
66976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66977       };
66978     } catch (...) {
66979       {
66980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66981       };
66982     }
66983   }
66984
66985   jresult = new Dali::Actor((const Dali::Actor &)result);
66986   return jresult;
66987 }
66988
66989
66990 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommitted(void * jarg1, void * jarg2) {
66991   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66992   Dali::Actor arg2 ;
66993   Dali::Actor *argp2 ;
66994
66995   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66996   argp2 = (Dali::Actor *)jarg2;
66997   if (!argp2) {
66998     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66999     return ;
67000   }
67001   arg2 = *argp2;
67002   {
67003     try {
67004       (arg1)->OnKeyboardFocusChangeCommitted(arg2);
67005     } catch (std::out_of_range& e) {
67006       {
67007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67008       };
67009     } catch (std::exception& e) {
67010       {
67011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67012       };
67013     } catch (Dali::DaliException e) {
67014       {
67015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67016       };
67017     } catch (...) {
67018       {
67019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67020       };
67021     }
67022   }
67023
67024 }
67025
67026
67027 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommittedSwigExplicitViewImpl(void * jarg1, void * jarg2) {
67028   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67029   Dali::Actor arg2 ;
67030   Dali::Actor *argp2 ;
67031
67032   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67033   argp2 = (Dali::Actor *)jarg2;
67034   if (!argp2) {
67035     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
67036     return ;
67037   }
67038   arg2 = *argp2;
67039   {
67040     try {
67041       (arg1)->Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(arg2);
67042     } catch (std::out_of_range& e) {
67043       {
67044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67045       };
67046     } catch (std::exception& e) {
67047       {
67048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67049       };
67050     } catch (Dali::DaliException e) {
67051       {
67052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67053       };
67054     } catch (...) {
67055       {
67056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67057       };
67058     }
67059   }
67060
67061 }
67062
67063
67064 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnter(void * jarg1) {
67065   unsigned int jresult ;
67066   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67067   bool result;
67068
67069   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67070   {
67071     try {
67072       result = (bool)(arg1)->OnKeyboardEnter();
67073     } catch (std::out_of_range& e) {
67074       {
67075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67076       };
67077     } catch (std::exception& e) {
67078       {
67079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67080       };
67081     } catch (Dali::DaliException e) {
67082       {
67083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67084       };
67085     } catch (...) {
67086       {
67087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67088       };
67089     }
67090   }
67091
67092   jresult = result;
67093   return jresult;
67094 }
67095
67096
67097 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnterSwigExplicitViewImpl(void * jarg1) {
67098   unsigned int jresult ;
67099   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67100   bool result;
67101
67102   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67103   {
67104     try {
67105       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnKeyboardEnter();
67106     } catch (std::out_of_range& e) {
67107       {
67108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67109       };
67110     } catch (std::exception& e) {
67111       {
67112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67113       };
67114     } catch (Dali::DaliException e) {
67115       {
67116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67117       };
67118     } catch (...) {
67119       {
67120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67121       };
67122     }
67123   }
67124
67125   jresult = result;
67126   return jresult;
67127 }
67128
67129
67130 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinch(void * jarg1, void * jarg2) {
67131   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67132   Dali::PinchGesture *arg2 = 0 ;
67133
67134   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67135   arg2 = (Dali::PinchGesture *)jarg2;
67136   if (!arg2) {
67137     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
67138     return ;
67139   }
67140   {
67141     try {
67142       (arg1)->OnPinch((Dali::PinchGesture const &)*arg2);
67143     } catch (std::out_of_range& e) {
67144       {
67145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67146       };
67147     } catch (std::exception& e) {
67148       {
67149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67150       };
67151     } catch (Dali::DaliException e) {
67152       {
67153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67154       };
67155     } catch (...) {
67156       {
67157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67158       };
67159     }
67160   }
67161
67162 }
67163
67164
67165 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
67166   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67167   Dali::PinchGesture *arg2 = 0 ;
67168
67169   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67170   arg2 = (Dali::PinchGesture *)jarg2;
67171   if (!arg2) {
67172     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
67173     return ;
67174   }
67175   {
67176     try {
67177       (arg1)->Dali::Toolkit::Internal::Control::OnPinch((Dali::PinchGesture const &)*arg2);
67178     } catch (std::out_of_range& e) {
67179       {
67180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67181       };
67182     } catch (std::exception& e) {
67183       {
67184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67185       };
67186     } catch (Dali::DaliException e) {
67187       {
67188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67189       };
67190     } catch (...) {
67191       {
67192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67193       };
67194     }
67195   }
67196
67197 }
67198
67199
67200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPan(void * jarg1, void * jarg2) {
67201   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67202   Dali::PanGesture *arg2 = 0 ;
67203
67204   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67205   arg2 = (Dali::PanGesture *)jarg2;
67206   if (!arg2) {
67207     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
67208     return ;
67209   }
67210   {
67211     try {
67212       (arg1)->OnPan((Dali::PanGesture const &)*arg2);
67213     } catch (std::out_of_range& e) {
67214       {
67215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67216       };
67217     } catch (std::exception& e) {
67218       {
67219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67220       };
67221     } catch (Dali::DaliException e) {
67222       {
67223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67224       };
67225     } catch (...) {
67226       {
67227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67228       };
67229     }
67230   }
67231
67232 }
67233
67234
67235 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
67236   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67237   Dali::PanGesture *arg2 = 0 ;
67238
67239   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67240   arg2 = (Dali::PanGesture *)jarg2;
67241   if (!arg2) {
67242     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
67243     return ;
67244   }
67245   {
67246     try {
67247       (arg1)->Dali::Toolkit::Internal::Control::OnPan((Dali::PanGesture const &)*arg2);
67248     } catch (std::out_of_range& e) {
67249       {
67250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67251       };
67252     } catch (std::exception& e) {
67253       {
67254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67255       };
67256     } catch (Dali::DaliException e) {
67257       {
67258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67259       };
67260     } catch (...) {
67261       {
67262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67263       };
67264     }
67265   }
67266
67267 }
67268
67269
67270 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTap(void * jarg1, void * jarg2) {
67271   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67272   Dali::TapGesture *arg2 = 0 ;
67273
67274   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67275   arg2 = (Dali::TapGesture *)jarg2;
67276   if (!arg2) {
67277     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
67278     return ;
67279   }
67280   {
67281     try {
67282       (arg1)->OnTap((Dali::TapGesture const &)*arg2);
67283     } catch (std::out_of_range& e) {
67284       {
67285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67286       };
67287     } catch (std::exception& e) {
67288       {
67289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67290       };
67291     } catch (Dali::DaliException e) {
67292       {
67293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67294       };
67295     } catch (...) {
67296       {
67297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67298       };
67299     }
67300   }
67301
67302 }
67303
67304
67305 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTapSwigExplicitViewImpl(void * jarg1, void * jarg2) {
67306   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67307   Dali::TapGesture *arg2 = 0 ;
67308
67309   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67310   arg2 = (Dali::TapGesture *)jarg2;
67311   if (!arg2) {
67312     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
67313     return ;
67314   }
67315   {
67316     try {
67317       (arg1)->Dali::Toolkit::Internal::Control::OnTap((Dali::TapGesture const &)*arg2);
67318     } catch (std::out_of_range& e) {
67319       {
67320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67321       };
67322     } catch (std::exception& e) {
67323       {
67324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67325       };
67326     } catch (Dali::DaliException e) {
67327       {
67328         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67329       };
67330     } catch (...) {
67331       {
67332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67333       };
67334     }
67335   }
67336
67337 }
67338
67339
67340 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPress(void * jarg1, void * jarg2) {
67341   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67342   Dali::LongPressGesture *arg2 = 0 ;
67343
67344   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67345   arg2 = (Dali::LongPressGesture *)jarg2;
67346   if (!arg2) {
67347     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
67348     return ;
67349   }
67350   {
67351     try {
67352       (arg1)->OnLongPress((Dali::LongPressGesture const &)*arg2);
67353     } catch (std::out_of_range& e) {
67354       {
67355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67356       };
67357     } catch (std::exception& e) {
67358       {
67359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67360       };
67361     } catch (Dali::DaliException e) {
67362       {
67363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67364       };
67365     } catch (...) {
67366       {
67367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67368       };
67369     }
67370   }
67371
67372 }
67373
67374
67375 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPressSwigExplicitViewImpl(void * jarg1, void * jarg2) {
67376   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67377   Dali::LongPressGesture *arg2 = 0 ;
67378
67379   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67380   arg2 = (Dali::LongPressGesture *)jarg2;
67381   if (!arg2) {
67382     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
67383     return ;
67384   }
67385   {
67386     try {
67387       (arg1)->Dali::Toolkit::Internal::Control::OnLongPress((Dali::LongPressGesture const &)*arg2);
67388     } catch (std::out_of_range& e) {
67389       {
67390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67391       };
67392     } catch (std::exception& e) {
67393       {
67394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67395       };
67396     } catch (Dali::DaliException e) {
67397       {
67398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67399       };
67400     } catch (...) {
67401       {
67402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67403       };
67404     }
67405   }
67406
67407 }
67408
67409
67410 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
67411   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67412   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
67413   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
67414
67415   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67416   arg2 = (Dali::SlotObserver *)jarg2;
67417   arg3 = (Dali::CallbackBase *)jarg3;
67418   {
67419     try {
67420       (arg1)->SignalConnected(arg2,arg3);
67421     } catch (std::out_of_range& e) {
67422       {
67423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67424       };
67425     } catch (std::exception& e) {
67426       {
67427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67428       };
67429     } catch (Dali::DaliException e) {
67430       {
67431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67432       };
67433     } catch (...) {
67434       {
67435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67436       };
67437     }
67438   }
67439
67440 }
67441
67442
67443 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
67444   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67445   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
67446   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
67447
67448   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67449   arg2 = (Dali::SlotObserver *)jarg2;
67450   arg3 = (Dali::CallbackBase *)jarg3;
67451   {
67452     try {
67453       (arg1)->Dali::Toolkit::Internal::Control::SignalConnected(arg2,arg3);
67454     } catch (std::out_of_range& e) {
67455       {
67456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67457       };
67458     } catch (std::exception& e) {
67459       {
67460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67461       };
67462     } catch (Dali::DaliException e) {
67463       {
67464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67465       };
67466     } catch (...) {
67467       {
67468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67469       };
67470     }
67471   }
67472
67473 }
67474
67475
67476 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
67477   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67478   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
67479   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
67480
67481   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67482   arg2 = (Dali::SlotObserver *)jarg2;
67483   arg3 = (Dali::CallbackBase *)jarg3;
67484   {
67485     try {
67486       (arg1)->SignalDisconnected(arg2,arg3);
67487     } catch (std::out_of_range& e) {
67488       {
67489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67490       };
67491     } catch (std::exception& e) {
67492       {
67493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67494       };
67495     } catch (Dali::DaliException e) {
67496       {
67497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67498       };
67499     } catch (...) {
67500       {
67501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67502       };
67503     }
67504   }
67505
67506 }
67507
67508
67509 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
67510   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67511   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
67512   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
67513
67514   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67515   arg2 = (Dali::SlotObserver *)jarg2;
67516   arg3 = (Dali::CallbackBase *)jarg3;
67517   {
67518     try {
67519       (arg1)->Dali::Toolkit::Internal::Control::SignalDisconnected(arg2,arg3);
67520     } catch (std::out_of_range& e) {
67521       {
67522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67523       };
67524     } catch (std::exception& e) {
67525       {
67526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67527       };
67528     } catch (Dali::DaliException e) {
67529       {
67530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67531       };
67532     } catch (...) {
67533       {
67534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67535       };
67536     }
67537   }
67538
67539 }
67540
67541
67542 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) {
67543   Dali::Toolkit::Internal::Control *obj = (Dali::Toolkit::Internal::Control *)objarg;
67544   SwigDirector_ViewImpl *director = dynamic_cast<SwigDirector_ViewImpl *>(obj);
67545   if (director) {
67546     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);
67547   }
67548 }
67549
67550
67551 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation__SWIG_0(void * jarg1) {
67552   void * jresult ;
67553   Dali::Toolkit::Control *arg1 = 0 ;
67554   Dali::Toolkit::Internal::Control *result = 0 ;
67555
67556   arg1 = (Dali::Toolkit::Control *)jarg1;
67557   if (!arg1) {
67558     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
67559     return 0;
67560   }
67561   {
67562     try {
67563       result = (Dali::Toolkit::Internal::Control *) &Dali::Toolkit::Internal::GetImplementation(*arg1);
67564     } catch (std::out_of_range& e) {
67565       {
67566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67567       };
67568     } catch (std::exception& e) {
67569       {
67570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67571       };
67572     } catch (Dali::DaliException e) {
67573       {
67574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67575       };
67576     } catch (...) {
67577       {
67578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67579       };
67580     }
67581   }
67582
67583   jresult = (void *)result;
67584   return jresult;
67585 }
67586
67587
67588 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_STYLE_NAME_get() {
67589   int jresult ;
67590   int result;
67591
67592   result = (int)Dali::Toolkit::Control::Property::STYLE_NAME;
67593   jresult = (int)result;
67594   return jresult;
67595 }
67596
67597
67598 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_COLOR_get() {
67599   int jresult ;
67600   int result;
67601
67602   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_COLOR;
67603   jresult = (int)result;
67604   return jresult;
67605 }
67606
67607
67608 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_IMAGE_get() {
67609   int jresult ;
67610   int result;
67611
67612   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_IMAGE;
67613   jresult = (int)result;
67614   return jresult;
67615 }
67616
67617
67618 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_KEY_INPUT_FOCUS_get() {
67619   int jresult ;
67620   int result;
67621
67622   result = (int)Dali::Toolkit::Control::Property::KEY_INPUT_FOCUS;
67623   jresult = (int)result;
67624   return jresult;
67625 }
67626
67627
67628 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_get() {
67629   int jresult ;
67630   int result;
67631
67632   result = (int)Dali::Toolkit::Control::Property::BACKGROUND;
67633   jresult = (int)result;
67634   return jresult;
67635 }
67636
67637 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_MARGIN_get() {
67638   int jresult ;
67639   int result;
67640
67641   result = (int)Dali::Toolkit::Control::Property::MARGIN;
67642   jresult = (int)result;
67643   return jresult;
67644 }
67645
67646
67647 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_PADDING_get() {
67648   int jresult ;
67649   int result;
67650
67651   result = (int)Dali::Toolkit::Control::Property::PADDING;
67652   jresult = (int)result;
67653   return jresult;
67654 }
67655
67656 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_Property() {
67657   void * jresult ;
67658   Dali::Toolkit::Control::Property *result = 0 ;
67659
67660   {
67661     try {
67662       result = (Dali::Toolkit::Control::Property *)new Dali::Toolkit::Control::Property();
67663     } catch (std::out_of_range& e) {
67664       {
67665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67666       };
67667     } catch (std::exception& e) {
67668       {
67669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67670       };
67671     } catch (Dali::DaliException e) {
67672       {
67673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67674       };
67675     } catch (...) {
67676       {
67677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67678       };
67679     }
67680   }
67681
67682   jresult = (void *)result;
67683   return jresult;
67684 }
67685
67686
67687 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_Property(void * jarg1) {
67688   Dali::Toolkit::Control::Property *arg1 = (Dali::Toolkit::Control::Property *) 0 ;
67689
67690   arg1 = (Dali::Toolkit::Control::Property *)jarg1;
67691   {
67692     try {
67693       delete arg1;
67694     } catch (std::out_of_range& e) {
67695       {
67696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67697       };
67698     } catch (std::exception& e) {
67699       {
67700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67701       };
67702     } catch (Dali::DaliException e) {
67703       {
67704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67705       };
67706     } catch (...) {
67707       {
67708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67709       };
67710     }
67711   }
67712
67713 }
67714
67715
67716 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_KeyboardFocus() {
67717   void * jresult ;
67718   Dali::Toolkit::Control::KeyboardFocus *result = 0 ;
67719
67720   {
67721     try {
67722       result = (Dali::Toolkit::Control::KeyboardFocus *)new Dali::Toolkit::Control::KeyboardFocus();
67723     } catch (std::out_of_range& e) {
67724       {
67725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67726       };
67727     } catch (std::exception& e) {
67728       {
67729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67730       };
67731     } catch (Dali::DaliException e) {
67732       {
67733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67734       };
67735     } catch (...) {
67736       {
67737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67738       };
67739     }
67740   }
67741
67742   jresult = (void *)result;
67743   return jresult;
67744 }
67745
67746
67747 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_KeyboardFocus(void * jarg1) {
67748   Dali::Toolkit::Control::KeyboardFocus *arg1 = (Dali::Toolkit::Control::KeyboardFocus *) 0 ;
67749
67750   arg1 = (Dali::Toolkit::Control::KeyboardFocus *)jarg1;
67751   {
67752     try {
67753       delete arg1;
67754     } catch (std::out_of_range& e) {
67755       {
67756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67757       };
67758     } catch (std::exception& e) {
67759       {
67760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67761       };
67762     } catch (Dali::DaliException e) {
67763       {
67764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67765       };
67766     } catch (...) {
67767       {
67768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67769       };
67770     }
67771   }
67772
67773 }
67774
67775
67776 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_New() {
67777   void * jresult ;
67778   Dali::Toolkit::Control result;
67779
67780   {
67781     try {
67782       result = Dali::Toolkit::Control::New();
67783     } catch (std::out_of_range& e) {
67784       {
67785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67786       };
67787     } catch (std::exception& e) {
67788       {
67789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67790       };
67791     } catch (Dali::DaliException e) {
67792       {
67793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67794       };
67795     } catch (...) {
67796       {
67797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67798       };
67799     }
67800   }
67801
67802   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
67803   return jresult;
67804 }
67805
67806
67807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_0() {
67808   void * jresult ;
67809   Dali::Toolkit::Control *result = 0 ;
67810
67811   {
67812     try {
67813       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control();
67814     } catch (std::out_of_range& e) {
67815       {
67816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67817       };
67818     } catch (std::exception& e) {
67819       {
67820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67821       };
67822     } catch (Dali::DaliException e) {
67823       {
67824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67825       };
67826     } catch (...) {
67827       {
67828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67829       };
67830     }
67831   }
67832
67833   jresult = (void *)result;
67834   return jresult;
67835 }
67836
67837
67838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_1(void * jarg1) {
67839   void * jresult ;
67840   Dali::Toolkit::Control *arg1 = 0 ;
67841   Dali::Toolkit::Control *result = 0 ;
67842
67843   arg1 = (Dali::Toolkit::Control *)jarg1;
67844   if (!arg1) {
67845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
67846     return 0;
67847   }
67848   {
67849     try {
67850       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control((Dali::Toolkit::Control const &)*arg1);
67851     } catch (std::out_of_range& e) {
67852       {
67853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67854       };
67855     } catch (std::exception& e) {
67856       {
67857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67858       };
67859     } catch (Dali::DaliException e) {
67860       {
67861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67862       };
67863     } catch (...) {
67864       {
67865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67866       };
67867     }
67868   }
67869
67870   jresult = (void *)result;
67871   return jresult;
67872 }
67873
67874
67875 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View(void * jarg1) {
67876   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67877
67878   arg1 = (Dali::Toolkit::Control *)jarg1;
67879   {
67880     try {
67881       delete arg1;
67882     } catch (std::out_of_range& e) {
67883       {
67884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67885       };
67886     } catch (std::exception& e) {
67887       {
67888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67889       };
67890     } catch (Dali::DaliException e) {
67891       {
67892         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67893       };
67894     } catch (...) {
67895       {
67896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67897       };
67898     }
67899   }
67900
67901 }
67902
67903
67904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_Assign(void * jarg1, void * jarg2) {
67905   void * jresult ;
67906   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67907   Dali::Toolkit::Control *arg2 = 0 ;
67908   Dali::Toolkit::Control *result = 0 ;
67909
67910   arg1 = (Dali::Toolkit::Control *)jarg1;
67911   arg2 = (Dali::Toolkit::Control *)jarg2;
67912   if (!arg2) {
67913     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
67914     return 0;
67915   }
67916   {
67917     try {
67918       result = (Dali::Toolkit::Control *) &(arg1)->operator =((Dali::Toolkit::Control const &)*arg2);
67919     } catch (std::out_of_range& e) {
67920       {
67921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67922       };
67923     } catch (std::exception& e) {
67924       {
67925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67926       };
67927     } catch (Dali::DaliException e) {
67928       {
67929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67930       };
67931     } catch (...) {
67932       {
67933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67934       };
67935     }
67936   }
67937
67938   jresult = (void *)result;
67939   return jresult;
67940 }
67941
67942
67943 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_DownCast(void * jarg1) {
67944   void * jresult ;
67945   Dali::BaseHandle arg1 ;
67946   Dali::BaseHandle *argp1 ;
67947   Dali::Toolkit::Control result;
67948
67949   argp1 = (Dali::BaseHandle *)jarg1;
67950   if (!argp1) {
67951     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67952     return 0;
67953   }
67954   arg1 = *argp1;
67955   {
67956     try {
67957       result = Dali::Toolkit::Control::DownCast(arg1);
67958     } catch (std::out_of_range& e) {
67959       {
67960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67961       };
67962     } catch (std::exception& e) {
67963       {
67964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67965       };
67966     } catch (Dali::DaliException e) {
67967       {
67968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67969       };
67970     } catch (...) {
67971       {
67972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67973       };
67974     }
67975   }
67976
67977   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
67978   return jresult;
67979 }
67980
67981
67982 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetKeyInputFocus(void * jarg1) {
67983   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67984
67985   arg1 = (Dali::Toolkit::Control *)jarg1;
67986   {
67987     try {
67988       (arg1)->SetKeyInputFocus();
67989     } catch (std::out_of_range& e) {
67990       {
67991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67992       };
67993     } catch (std::exception& e) {
67994       {
67995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67996       };
67997     } catch (Dali::DaliException e) {
67998       {
67999         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68000       };
68001     } catch (...) {
68002       {
68003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68004       };
68005     }
68006   }
68007
68008 }
68009
68010
68011 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_View_HasKeyInputFocus(void * jarg1) {
68012   unsigned int jresult ;
68013   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68014   bool result;
68015
68016   arg1 = (Dali::Toolkit::Control *)jarg1;
68017   {
68018     try {
68019       result = (bool)(arg1)->HasKeyInputFocus();
68020     } catch (std::out_of_range& e) {
68021       {
68022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68023       };
68024     } catch (std::exception& e) {
68025       {
68026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68027       };
68028     } catch (Dali::DaliException e) {
68029       {
68030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68031       };
68032     } catch (...) {
68033       {
68034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68035       };
68036     }
68037   }
68038
68039   jresult = result;
68040   return jresult;
68041 }
68042
68043
68044 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearKeyInputFocus(void * jarg1) {
68045   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68046
68047   arg1 = (Dali::Toolkit::Control *)jarg1;
68048   {
68049     try {
68050       (arg1)->ClearKeyInputFocus();
68051     } catch (std::out_of_range& e) {
68052       {
68053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68054       };
68055     } catch (std::exception& e) {
68056       {
68057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68058       };
68059     } catch (Dali::DaliException e) {
68060       {
68061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68062       };
68063     } catch (...) {
68064       {
68065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68066       };
68067     }
68068   }
68069
68070 }
68071
68072
68073 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPinchGestureDetector(void * jarg1) {
68074   void * jresult ;
68075   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68076   Dali::PinchGestureDetector result;
68077
68078   arg1 = (Dali::Toolkit::Control *)jarg1;
68079   {
68080     try {
68081       result = ((Dali::Toolkit::Control const *)arg1)->GetPinchGestureDetector();
68082     } catch (std::out_of_range& e) {
68083       {
68084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68085       };
68086     } catch (std::exception& e) {
68087       {
68088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68089       };
68090     } catch (Dali::DaliException e) {
68091       {
68092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68093       };
68094     } catch (...) {
68095       {
68096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68097       };
68098     }
68099   }
68100
68101   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
68102   return jresult;
68103 }
68104
68105
68106 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPanGestureDetector(void * jarg1) {
68107   void * jresult ;
68108   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68109   Dali::PanGestureDetector result;
68110
68111   arg1 = (Dali::Toolkit::Control *)jarg1;
68112   {
68113     try {
68114       result = ((Dali::Toolkit::Control const *)arg1)->GetPanGestureDetector();
68115     } catch (std::out_of_range& e) {
68116       {
68117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68118       };
68119     } catch (std::exception& e) {
68120       {
68121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68122       };
68123     } catch (Dali::DaliException e) {
68124       {
68125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68126       };
68127     } catch (...) {
68128       {
68129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68130       };
68131     }
68132   }
68133
68134   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
68135   return jresult;
68136 }
68137
68138
68139 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetTapGestureDetector(void * jarg1) {
68140   void * jresult ;
68141   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68142   Dali::TapGestureDetector result;
68143
68144   arg1 = (Dali::Toolkit::Control *)jarg1;
68145   {
68146     try {
68147       result = ((Dali::Toolkit::Control const *)arg1)->GetTapGestureDetector();
68148     } catch (std::out_of_range& e) {
68149       {
68150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68151       };
68152     } catch (std::exception& e) {
68153       {
68154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68155       };
68156     } catch (Dali::DaliException e) {
68157       {
68158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68159       };
68160     } catch (...) {
68161       {
68162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68163       };
68164     }
68165   }
68166
68167   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
68168   return jresult;
68169 }
68170
68171
68172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetLongPressGestureDetector(void * jarg1) {
68173   void * jresult ;
68174   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68175   Dali::LongPressGestureDetector result;
68176
68177   arg1 = (Dali::Toolkit::Control *)jarg1;
68178   {
68179     try {
68180       result = ((Dali::Toolkit::Control const *)arg1)->GetLongPressGestureDetector();
68181     } catch (std::out_of_range& e) {
68182       {
68183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68184       };
68185     } catch (std::exception& e) {
68186       {
68187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68188       };
68189     } catch (Dali::DaliException e) {
68190       {
68191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68192       };
68193     } catch (...) {
68194       {
68195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68196       };
68197     }
68198   }
68199
68200   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
68201   return jresult;
68202 }
68203
68204
68205 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetStyleName(void * jarg1, char * jarg2) {
68206   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68207   std::string *arg2 = 0 ;
68208
68209   arg1 = (Dali::Toolkit::Control *)jarg1;
68210   if (!jarg2) {
68211     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
68212     return ;
68213   }
68214   std::string arg2_str(jarg2);
68215   arg2 = &arg2_str;
68216   {
68217     try {
68218       (arg1)->SetStyleName((std::string const &)*arg2);
68219     } catch (std::out_of_range& e) {
68220       {
68221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68222       };
68223     } catch (std::exception& e) {
68224       {
68225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68226       };
68227     } catch (Dali::DaliException e) {
68228       {
68229         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68230       };
68231     } catch (...) {
68232       {
68233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68234       };
68235     }
68236   }
68237
68238
68239   //argout typemap for const std::string&
68240
68241 }
68242
68243
68244 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_View_GetStyleName(void * jarg1) {
68245   char * jresult ;
68246   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68247   std::string *result = 0 ;
68248
68249   arg1 = (Dali::Toolkit::Control *)jarg1;
68250   {
68251     try {
68252       result = (std::string *) &((Dali::Toolkit::Control const *)arg1)->GetStyleName();
68253     } catch (std::out_of_range& e) {
68254       {
68255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68256       };
68257     } catch (std::exception& e) {
68258       {
68259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68260       };
68261     } catch (Dali::DaliException e) {
68262       {
68263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68264       };
68265     } catch (...) {
68266       {
68267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68268       };
68269     }
68270   }
68271
68272   jresult = SWIG_csharp_string_callback(result->c_str());
68273   return jresult;
68274 }
68275
68276
68277 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundColor(void * jarg1, void * jarg2) {
68278   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68279   Dali::Vector4 *arg2 = 0 ;
68280
68281   arg1 = (Dali::Toolkit::Control *)jarg1;
68282   arg2 = (Dali::Vector4 *)jarg2;
68283   if (!arg2) {
68284     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
68285     return ;
68286   }
68287   {
68288     try {
68289       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
68290     } catch (std::out_of_range& e) {
68291       {
68292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68293       };
68294     } catch (std::exception& e) {
68295       {
68296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68297       };
68298     } catch (Dali::DaliException e) {
68299       {
68300         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68301       };
68302     } catch (...) {
68303       {
68304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68305       };
68306     }
68307   }
68308
68309 }
68310
68311
68312 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetBackgroundColor(void * jarg1) {
68313   void * jresult ;
68314   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68315   Dali::Vector4 result;
68316
68317   arg1 = (Dali::Toolkit::Control *)jarg1;
68318   {
68319     try {
68320       result = ((Dali::Toolkit::Control const *)arg1)->GetBackgroundColor();
68321     } catch (std::out_of_range& e) {
68322       {
68323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68324       };
68325     } catch (std::exception& e) {
68326       {
68327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68328       };
68329     } catch (Dali::DaliException e) {
68330       {
68331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68332       };
68333     } catch (...) {
68334       {
68335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68336       };
68337     }
68338   }
68339
68340   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
68341   return jresult;
68342 }
68343
68344
68345 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundImage(void * jarg1, void * jarg2) {
68346   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68347   Dali::Image arg2 ;
68348   Dali::Image *argp2 ;
68349
68350   arg1 = (Dali::Toolkit::Control *)jarg1;
68351   argp2 = (Dali::Image *)jarg2;
68352   if (!argp2) {
68353     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
68354     return ;
68355   }
68356   arg2 = *argp2;
68357   {
68358     try {
68359       (arg1)->SetBackgroundImage(arg2);
68360     } catch (std::out_of_range& e) {
68361       {
68362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68363       };
68364     } catch (std::exception& e) {
68365       {
68366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68367       };
68368     } catch (Dali::DaliException e) {
68369       {
68370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68371       };
68372     } catch (...) {
68373       {
68374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68375       };
68376     }
68377   }
68378
68379 }
68380
68381
68382 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearBackground(void * jarg1) {
68383   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68384
68385   arg1 = (Dali::Toolkit::Control *)jarg1;
68386   {
68387     try {
68388       (arg1)->ClearBackground();
68389     } catch (std::out_of_range& e) {
68390       {
68391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68392       };
68393     } catch (std::exception& e) {
68394       {
68395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68396       };
68397     } catch (Dali::DaliException e) {
68398       {
68399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68400       };
68401     } catch (...) {
68402       {
68403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68404       };
68405     }
68406   }
68407
68408 }
68409
68410
68411 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyEventSignal(void * jarg1) {
68412   void * jresult ;
68413   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68414   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
68415
68416   arg1 = (Dali::Toolkit::Control *)jarg1;
68417   {
68418     try {
68419       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
68420     } catch (std::out_of_range& e) {
68421       {
68422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68423       };
68424     } catch (std::exception& e) {
68425       {
68426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68427       };
68428     } catch (Dali::DaliException e) {
68429       {
68430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68431       };
68432     } catch (...) {
68433       {
68434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68435       };
68436     }
68437   }
68438
68439   jresult = (void *)result;
68440   return jresult;
68441 }
68442
68443
68444 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusGainedSignal(void * jarg1) {
68445   void * jresult ;
68446   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68447   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
68448
68449   arg1 = (Dali::Toolkit::Control *)jarg1;
68450   {
68451     try {
68452       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
68453     } catch (std::out_of_range& e) {
68454       {
68455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68456       };
68457     } catch (std::exception& e) {
68458       {
68459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68460       };
68461     } catch (Dali::DaliException e) {
68462       {
68463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68464       };
68465     } catch (...) {
68466       {
68467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68468       };
68469     }
68470   }
68471
68472   jresult = (void *)result;
68473   return jresult;
68474 }
68475
68476
68477 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusLostSignal(void * jarg1) {
68478   void * jresult ;
68479   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68480   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
68481
68482   arg1 = (Dali::Toolkit::Control *)jarg1;
68483   {
68484     try {
68485       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
68486     } catch (std::out_of_range& e) {
68487       {
68488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68489       };
68490     } catch (std::exception& e) {
68491       {
68492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68493       };
68494     } catch (Dali::DaliException e) {
68495       {
68496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68497       };
68498     } catch (...) {
68499       {
68500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68501       };
68502     }
68503   }
68504
68505   jresult = (void *)result;
68506   return jresult;
68507 }
68508
68509
68510 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_2(void * jarg1) {
68511   void * jresult ;
68512   Dali::Toolkit::Internal::Control *arg1 = 0 ;
68513   Dali::Toolkit::Control *result = 0 ;
68514
68515   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
68516   if (!arg1) {
68517     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
68518     return 0;
68519   }
68520   {
68521     try {
68522       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control(*arg1);
68523     } catch (std::out_of_range& e) {
68524       {
68525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68526       };
68527     } catch (std::exception& e) {
68528       {
68529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68530       };
68531     } catch (Dali::DaliException e) {
68532       {
68533         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68534       };
68535     } catch (...) {
68536       {
68537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68538       };
68539     }
68540   }
68541
68542   jresult = (void *)result;
68543   return jresult;
68544 }
68545
68546 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_GetVisualResourceStatus(void * jarg1, int jarg2)
68547 {
68548   int jresult;
68549   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68550   arg1 = (Dali::Toolkit::Control *)jarg1;
68551
68552   if (!arg1) {
68553     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
68554     return 0;
68555   }
68556
68557   Dali::Property::Index arg2 = 0 ;
68558   arg2 = (Dali::Property::Index)jarg2;
68559
68560   Toolkit::Visual::ResourceStatus result;
68561   {
68562     try {
68563       result = arg1->GetVisualResourceStatus(arg2);
68564     } catch (std::out_of_range& e) {
68565       {
68566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68567       };
68568     } catch (std::exception& e) {
68569       {
68570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68571       };
68572     } catch (...) {
68573       {
68574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68575       };
68576     }
68577   }
68578   jresult = (int)(result);
68579   return jresult;
68580 }
68581
68582 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_CreateTransition(void * jarg1, void * jarg2)
68583 {
68584   void * jresult;
68585   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68586   arg1 = (Dali::Toolkit::Control *)jarg1;
68587
68588   Dali::Toolkit::Internal::Control& controlImpl = Dali::Toolkit::Internal::GetImplementation( *arg1 );
68589
68590   Dali::Toolkit::TransitionData *arg2 = 0 ;
68591   Dali::Animation result;
68592
68593   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
68594   if (!arg2) {
68595     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
68596     return 0;
68597   }
68598   {
68599     try {
68600       result = DevelControl::CreateTransition( controlImpl, (Dali::Toolkit::TransitionData const &)*arg2);
68601     } catch (std::out_of_range& e) {
68602       {
68603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68604       };
68605     } catch (std::exception& e) {
68606       {
68607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68608       };
68609     } catch (Dali::DaliException e) {
68610       {
68611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68612       };
68613     } catch (...) {
68614       {
68615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68616       };
68617     }
68618   }
68619
68620   jresult = new Dali::Animation((const Dali::Animation &)result);
68621   return jresult;
68622 }
68623
68624 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_DoAction(void * jarg1, int jarg2, int jarg3, void * jarg4 )
68625 {
68626   Dali::Toolkit::Control arg1;
68627   Dali::Toolkit::Control *argp1  = (Dali::Toolkit::Control *)jarg1;
68628
68629   if (!argp1) {
68630     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
68631   }
68632   arg1 = *argp1;
68633
68634   Dali::Property::Index arg2 = 0 ;
68635   arg2 = (Dali::Property::Index)jarg2;
68636
68637   Dali::Property::Index arg3 = 0 ;
68638   arg3 = (Dali::Property::Index)jarg3;
68639
68640   Dali::Property::Value arg4;
68641   arg4 = (Dali::Property::Value *)jarg4;
68642
68643   {
68644     try {
68645       DevelControl::DoAction(arg1, arg2, arg3, arg4);
68646     } catch (std::out_of_range& e) {
68647       {
68648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68649       };
68650     } catch (std::exception& e) {
68651       {
68652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68653       };
68654     } catch (...) {
68655       {
68656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68657       };
68658     }
68659   }
68660
68661
68662 }
68663
68664 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetLayout__SWIG_0(void * jarg1) {
68665   void * jresult ;
68666   Dali::Toolkit::Internal::Control *arg1 = 0 ;
68667   Dali::Toolkit::LayoutItem result;
68668
68669   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
68670   if (!arg1) {
68671     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
68672     return 0;
68673   }
68674   {
68675     try {
68676       result = Dali::Toolkit::DevelControl::GetLayout(*arg1);
68677     } catch (std::out_of_range& e) {
68678       {
68679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68680       };
68681     } catch (std::exception& e) {
68682       {
68683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68684       };
68685     } catch (...) {
68686       {
68687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68688       };
68689     }
68690   }
68691   jresult = new Dali::Toolkit::LayoutItem((const Dali::Toolkit::LayoutItem &)result);
68692   return jresult;
68693 }
68694
68695
68696 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetLayout__SWIG_1(void * jarg1) {
68697   void * jresult ;
68698   Dali::Toolkit::Control arg1 ;
68699   Dali::Toolkit::Control *argp1 ;
68700   Dali::Toolkit::LayoutItem result;
68701
68702   argp1 = (Dali::Toolkit::Control *)jarg1;
68703   if (!argp1) {
68704     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
68705     return 0;
68706   }
68707   arg1 = *argp1;
68708   {
68709     try {
68710       result = Dali::Toolkit::DevelControl::GetLayout(arg1);
68711     } catch (std::out_of_range& e) {
68712       {
68713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68714       };
68715     } catch (std::exception& e) {
68716       {
68717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68718       };
68719     } catch (...) {
68720       {
68721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68722       };
68723     }
68724   }
68725   jresult = new Dali::Toolkit::LayoutItem((const Dali::Toolkit::LayoutItem &)result);
68726   return jresult;
68727 }
68728
68729 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetLayout__SWIG_0(void * jarg1, void * jarg2) {
68730   Dali::Toolkit::Internal::Control *arg1 = 0 ;
68731   Dali::Toolkit::LayoutItem arg2 ;
68732   Dali::Toolkit::LayoutItem *argp2 ;
68733
68734   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
68735   if (!arg1) {
68736     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
68737     return ;
68738   }
68739   argp2 = (Dali::Toolkit::LayoutItem *)jarg2;
68740   if (!argp2) {
68741     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutItem", 0);
68742     return ;
68743   }
68744   arg2 = *argp2;
68745   {
68746     try {
68747       Dali::Toolkit::DevelControl::SetLayout(*arg1,arg2);
68748     } catch (std::out_of_range& e) {
68749       {
68750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68751       };
68752     } catch (std::exception& e) {
68753       {
68754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68755       };
68756     } catch (...) {
68757       {
68758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68759       };
68760     }
68761   }
68762 }
68763
68764
68765 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetLayout__SWIG_1(void * jarg1, void * jarg2) {
68766   Dali::Toolkit::Control arg1 ;
68767   Dali::Toolkit::LayoutItem arg2 ;
68768   Dali::Toolkit::Control *argp1 ;
68769   Dali::Toolkit::LayoutItem *argp2 ;
68770
68771   argp1 = (Dali::Toolkit::Control *)jarg1;
68772   if (!argp1) {
68773     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
68774     return ;
68775   }
68776   arg1 = *argp1;
68777   argp2 = (Dali::Toolkit::LayoutItem *)jarg2;
68778   if (!argp2) {
68779     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutItem", 0);
68780     return ;
68781   }
68782   arg2 = *argp2;
68783   {
68784     try {
68785       Dali::Toolkit::DevelControl::SetLayout(arg1,arg2);
68786     } catch (std::out_of_range& e) {
68787       {
68788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68789       };
68790     } catch (std::exception& e) {
68791       {
68792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68793       };
68794     } catch (...) {
68795       {
68796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68797       };
68798     }
68799   }
68800 }
68801
68802 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceReadySignal(void * jarg1) {
68803   void * jresult ;
68804   Dali::Toolkit::Control *arg1 = 0 ;
68805   Dali::Toolkit::Control::ResourceReadySignalType *result = 0 ;
68806
68807   arg1 = (Dali::Toolkit::Control *)jarg1;
68808   if (!arg1) {
68809     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
68810     return 0;
68811   }
68812   {
68813     try {
68814       result = (Dali::Toolkit::Control::ResourceReadySignalType *) &arg1->ResourceReadySignal();
68815     } catch (std::out_of_range& e) {
68816       {
68817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68818       };
68819     } catch (std::exception& e) {
68820       {
68821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68822       };
68823     } catch (Dali::DaliException e) {
68824       {
68825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68826       };
68827     } catch (...) {
68828       {
68829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68830       };
68831     }
68832   }
68833
68834   jresult = (void *)result;
68835   return jresult;
68836 }
68837
68838
68839 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsResourceReady(void * jarg1) {
68840   unsigned int jresult ;
68841   Dali::Toolkit::Control *arg1 = 0 ;
68842   bool result;
68843
68844   arg1 = (Dali::Toolkit::Control *)jarg1;
68845   if (!arg1) {
68846     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
68847     return 0;
68848   }
68849   {
68850     try {
68851       result = (bool)arg1->IsResourceReady();
68852     } catch (std::out_of_range& e) {
68853       {
68854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68855       };
68856     } catch (std::exception& e) {
68857       {
68858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68859       };
68860     } catch (Dali::DaliException e) {
68861       {
68862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68863       };
68864     } catch (...) {
68865       {
68866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68867       };
68868     }
68869   }
68870
68871   jresult = result;
68872   return jresult;
68873 }
68874
68875
68876 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusManager() {
68877   void * jresult ;
68878   Dali::Toolkit::KeyInputFocusManager *result = 0 ;
68879
68880   {
68881     try {
68882       result = (Dali::Toolkit::KeyInputFocusManager *)new Dali::Toolkit::KeyInputFocusManager();
68883     } catch (std::out_of_range& e) {
68884       {
68885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68886       };
68887     } catch (std::exception& e) {
68888       {
68889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68890       };
68891     } catch (Dali::DaliException e) {
68892       {
68893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68894       };
68895     } catch (...) {
68896       {
68897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68898       };
68899     }
68900   }
68901
68902   jresult = (void *)result;
68903   return jresult;
68904 }
68905
68906
68907 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusManager(void * jarg1) {
68908   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68909
68910   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68911   {
68912     try {
68913       delete arg1;
68914     } catch (std::out_of_range& e) {
68915       {
68916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68917       };
68918     } catch (std::exception& e) {
68919       {
68920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68921       };
68922     } catch (Dali::DaliException e) {
68923       {
68924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68925       };
68926     } catch (...) {
68927       {
68928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68929       };
68930     }
68931   }
68932
68933 }
68934
68935
68936 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_Get() {
68937   void * jresult ;
68938   Dali::Toolkit::KeyInputFocusManager result;
68939
68940   {
68941     try {
68942       result = Dali::Toolkit::KeyInputFocusManager::Get();
68943     } catch (std::out_of_range& e) {
68944       {
68945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68946       };
68947     } catch (std::exception& e) {
68948       {
68949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68950       };
68951     } catch (Dali::DaliException e) {
68952       {
68953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68954       };
68955     } catch (...) {
68956       {
68957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68958       };
68959     }
68960   }
68961
68962   jresult = new Dali::Toolkit::KeyInputFocusManager((const Dali::Toolkit::KeyInputFocusManager &)result);
68963   return jresult;
68964 }
68965
68966
68967 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SetFocus(void * jarg1, void * jarg2) {
68968   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68969   Dali::Toolkit::Control arg2 ;
68970   Dali::Toolkit::Control *argp2 ;
68971
68972   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68973   argp2 = (Dali::Toolkit::Control *)jarg2;
68974   if (!argp2) {
68975     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
68976     return ;
68977   }
68978   arg2 = *argp2;
68979   {
68980     try {
68981       (arg1)->SetFocus(arg2);
68982     } catch (std::out_of_range& e) {
68983       {
68984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68985       };
68986     } catch (std::exception& e) {
68987       {
68988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68989       };
68990     } catch (Dali::DaliException e) {
68991       {
68992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68993       };
68994     } catch (...) {
68995       {
68996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68997       };
68998     }
68999   }
69000
69001 }
69002
69003
69004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_GetCurrentFocusControl(void * jarg1) {
69005   void * jresult ;
69006   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
69007   Dali::Toolkit::Control result;
69008
69009   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
69010   {
69011     try {
69012       result = ((Dali::Toolkit::KeyInputFocusManager const *)arg1)->GetCurrentFocusControl();
69013     } catch (std::out_of_range& e) {
69014       {
69015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69016       };
69017     } catch (std::exception& e) {
69018       {
69019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69020       };
69021     } catch (Dali::DaliException e) {
69022       {
69023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69024       };
69025     } catch (...) {
69026       {
69027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69028       };
69029     }
69030   }
69031
69032   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
69033   return jresult;
69034 }
69035
69036
69037 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_RemoveFocus(void * jarg1, void * jarg2) {
69038   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
69039   Dali::Toolkit::Control arg2 ;
69040   Dali::Toolkit::Control *argp2 ;
69041
69042   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
69043   argp2 = (Dali::Toolkit::Control *)jarg2;
69044   if (!argp2) {
69045     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
69046     return ;
69047   }
69048   arg2 = *argp2;
69049   {
69050     try {
69051       (arg1)->RemoveFocus(arg2);
69052     } catch (std::out_of_range& e) {
69053       {
69054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69055       };
69056     } catch (std::exception& e) {
69057       {
69058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69059       };
69060     } catch (Dali::DaliException e) {
69061       {
69062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69063       };
69064     } catch (...) {
69065       {
69066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69067       };
69068     }
69069   }
69070
69071 }
69072
69073
69074 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_KeyInputFocusChangedSignal(void * jarg1) {
69075   void * jresult ;
69076   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
69077   Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *result = 0 ;
69078
69079   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
69080   {
69081     try {
69082       result = (Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *) &(arg1)->KeyInputFocusChangedSignal();
69083     } catch (std::out_of_range& e) {
69084       {
69085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69086       };
69087     } catch (std::exception& e) {
69088       {
69089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69090       };
69091     } catch (Dali::DaliException e) {
69092       {
69093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69094       };
69095     } catch (...) {
69096       {
69097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69098       };
69099     }
69100   }
69101
69102   jresult = (void *)result;
69103   return jresult;
69104 }
69105
69106
69107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_0() {
69108   void * jresult ;
69109   Dali::Toolkit::Alignment::Padding *result = 0 ;
69110
69111   {
69112     try {
69113       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding();
69114     } catch (std::out_of_range& e) {
69115       {
69116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69117       };
69118     } catch (std::exception& e) {
69119       {
69120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69121       };
69122     } catch (Dali::DaliException e) {
69123       {
69124         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69125       };
69126     } catch (...) {
69127       {
69128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69129       };
69130     }
69131   }
69132
69133   jresult = (void *)result;
69134   return jresult;
69135 }
69136
69137
69138 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
69139   void * jresult ;
69140   float arg1 ;
69141   float arg2 ;
69142   float arg3 ;
69143   float arg4 ;
69144   Dali::Toolkit::Alignment::Padding *result = 0 ;
69145
69146   arg1 = (float)jarg1;
69147   arg2 = (float)jarg2;
69148   arg3 = (float)jarg3;
69149   arg4 = (float)jarg4;
69150   {
69151     try {
69152       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding(arg1,arg2,arg3,arg4);
69153     } catch (std::out_of_range& e) {
69154       {
69155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69156       };
69157     } catch (std::exception& e) {
69158       {
69159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69160       };
69161     } catch (Dali::DaliException e) {
69162       {
69163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69164       };
69165     } catch (...) {
69166       {
69167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69168       };
69169     }
69170   }
69171
69172   jresult = (void *)result;
69173   return jresult;
69174 }
69175
69176
69177 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_set(void * jarg1, float jarg2) {
69178   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
69179   float arg2 ;
69180
69181   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
69182   arg2 = (float)jarg2;
69183   if (arg1) (arg1)->left = arg2;
69184 }
69185
69186
69187 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_get(void * jarg1) {
69188   float jresult ;
69189   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
69190   float result;
69191
69192   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
69193   result = (float) ((arg1)->left);
69194   jresult = result;
69195   return jresult;
69196 }
69197
69198
69199 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_set(void * jarg1, float jarg2) {
69200   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
69201   float arg2 ;
69202
69203   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
69204   arg2 = (float)jarg2;
69205   if (arg1) (arg1)->right = arg2;
69206 }
69207
69208
69209 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_get(void * jarg1) {
69210   float jresult ;
69211   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
69212   float result;
69213
69214   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
69215   result = (float) ((arg1)->right);
69216   jresult = result;
69217   return jresult;
69218 }
69219
69220
69221 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_set(void * jarg1, float jarg2) {
69222   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
69223   float arg2 ;
69224
69225   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
69226   arg2 = (float)jarg2;
69227   if (arg1) (arg1)->top = arg2;
69228 }
69229
69230
69231 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_get(void * jarg1) {
69232   float jresult ;
69233   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
69234   float result;
69235
69236   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
69237   result = (float) ((arg1)->top);
69238   jresult = result;
69239   return jresult;
69240 }
69241
69242
69243 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_set(void * jarg1, float jarg2) {
69244   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
69245   float arg2 ;
69246
69247   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
69248   arg2 = (float)jarg2;
69249   if (arg1) (arg1)->bottom = arg2;
69250 }
69251
69252
69253 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_get(void * jarg1) {
69254   float jresult ;
69255   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
69256   float result;
69257
69258   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
69259   result = (float) ((arg1)->bottom);
69260   jresult = result;
69261   return jresult;
69262 }
69263
69264
69265 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment_Padding(void * jarg1) {
69266   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
69267
69268   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
69269   {
69270     try {
69271       delete arg1;
69272     } catch (std::out_of_range& e) {
69273       {
69274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69275       };
69276     } catch (std::exception& e) {
69277       {
69278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69279       };
69280     } catch (Dali::DaliException e) {
69281       {
69282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69283       };
69284     } catch (...) {
69285       {
69286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69287       };
69288     }
69289   }
69290
69291 }
69292
69293
69294 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_0() {
69295   void * jresult ;
69296   Dali::Toolkit::Alignment *result = 0 ;
69297
69298   {
69299     try {
69300       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment();
69301     } catch (std::out_of_range& e) {
69302       {
69303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69304       };
69305     } catch (std::exception& e) {
69306       {
69307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69308       };
69309     } catch (Dali::DaliException e) {
69310       {
69311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69312       };
69313     } catch (...) {
69314       {
69315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69316       };
69317     }
69318   }
69319
69320   jresult = (void *)result;
69321   return jresult;
69322 }
69323
69324
69325 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_0(int jarg1, int jarg2) {
69326   void * jresult ;
69327   Dali::Toolkit::Alignment::Type arg1 ;
69328   Dali::Toolkit::Alignment::Type arg2 ;
69329   Dali::Toolkit::Alignment result;
69330
69331   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
69332   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
69333   {
69334     try {
69335       result = Dali::Toolkit::Alignment::New(arg1,arg2);
69336     } catch (std::out_of_range& e) {
69337       {
69338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69339       };
69340     } catch (std::exception& e) {
69341       {
69342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69343       };
69344     } catch (Dali::DaliException e) {
69345       {
69346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69347       };
69348     } catch (...) {
69349       {
69350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69351       };
69352     }
69353   }
69354
69355   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
69356   return jresult;
69357 }
69358
69359
69360 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_1(int jarg1) {
69361   void * jresult ;
69362   Dali::Toolkit::Alignment::Type arg1 ;
69363   Dali::Toolkit::Alignment result;
69364
69365   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
69366   {
69367     try {
69368       result = Dali::Toolkit::Alignment::New(arg1);
69369     } catch (std::out_of_range& e) {
69370       {
69371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69372       };
69373     } catch (std::exception& e) {
69374       {
69375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69376       };
69377     } catch (Dali::DaliException e) {
69378       {
69379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69380       };
69381     } catch (...) {
69382       {
69383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69384       };
69385     }
69386   }
69387
69388   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
69389   return jresult;
69390 }
69391
69392
69393 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_2() {
69394   void * jresult ;
69395   Dali::Toolkit::Alignment result;
69396
69397   {
69398     try {
69399       result = Dali::Toolkit::Alignment::New();
69400     } catch (std::out_of_range& e) {
69401       {
69402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69403       };
69404     } catch (std::exception& e) {
69405       {
69406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69407       };
69408     } catch (Dali::DaliException e) {
69409       {
69410         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69411       };
69412     } catch (...) {
69413       {
69414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69415       };
69416     }
69417   }
69418
69419   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
69420   return jresult;
69421 }
69422
69423
69424 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_1(void * jarg1) {
69425   void * jresult ;
69426   Dali::Toolkit::Alignment *arg1 = 0 ;
69427   Dali::Toolkit::Alignment *result = 0 ;
69428
69429   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69430   if (!arg1) {
69431     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
69432     return 0;
69433   }
69434   {
69435     try {
69436       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment((Dali::Toolkit::Alignment const &)*arg1);
69437     } catch (std::out_of_range& e) {
69438       {
69439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69440       };
69441     } catch (std::exception& e) {
69442       {
69443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69444       };
69445     } catch (Dali::DaliException e) {
69446       {
69447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69448       };
69449     } catch (...) {
69450       {
69451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69452       };
69453     }
69454   }
69455
69456   jresult = (void *)result;
69457   return jresult;
69458 }
69459
69460
69461 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment(void * jarg1) {
69462   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69463
69464   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69465   {
69466     try {
69467       delete arg1;
69468     } catch (std::out_of_range& e) {
69469       {
69470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69471       };
69472     } catch (std::exception& e) {
69473       {
69474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69475       };
69476     } catch (Dali::DaliException e) {
69477       {
69478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69479       };
69480     } catch (...) {
69481       {
69482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69483       };
69484     }
69485   }
69486
69487 }
69488
69489
69490 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_DownCast(void * jarg1) {
69491   void * jresult ;
69492   Dali::BaseHandle arg1 ;
69493   Dali::BaseHandle *argp1 ;
69494   Dali::Toolkit::Alignment result;
69495
69496   argp1 = (Dali::BaseHandle *)jarg1;
69497   if (!argp1) {
69498     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
69499     return 0;
69500   }
69501   arg1 = *argp1;
69502   {
69503     try {
69504       result = Dali::Toolkit::Alignment::DownCast(arg1);
69505     } catch (std::out_of_range& e) {
69506       {
69507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69508       };
69509     } catch (std::exception& e) {
69510       {
69511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69512       };
69513     } catch (Dali::DaliException e) {
69514       {
69515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69516       };
69517     } catch (...) {
69518       {
69519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69520       };
69521     }
69522   }
69523
69524   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
69525   return jresult;
69526 }
69527
69528
69529 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetAlignmentType(void * jarg1, int jarg2) {
69530   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69531   Dali::Toolkit::Alignment::Type arg2 ;
69532
69533   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69534   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
69535   {
69536     try {
69537       (arg1)->SetAlignmentType(arg2);
69538     } catch (std::out_of_range& e) {
69539       {
69540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69541       };
69542     } catch (std::exception& e) {
69543       {
69544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69545       };
69546     } catch (Dali::DaliException e) {
69547       {
69548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69549       };
69550     } catch (...) {
69551       {
69552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69553       };
69554     }
69555   }
69556
69557 }
69558
69559
69560 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetAlignmentType(void * jarg1) {
69561   int jresult ;
69562   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69563   Dali::Toolkit::Alignment::Type result;
69564
69565   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69566   {
69567     try {
69568       result = (Dali::Toolkit::Alignment::Type)((Dali::Toolkit::Alignment const *)arg1)->GetAlignmentType();
69569     } catch (std::out_of_range& e) {
69570       {
69571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69572       };
69573     } catch (std::exception& e) {
69574       {
69575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69576       };
69577     } catch (Dali::DaliException e) {
69578       {
69579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69580       };
69581     } catch (...) {
69582       {
69583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69584       };
69585     }
69586   }
69587
69588   jresult = (int)result;
69589   return jresult;
69590 }
69591
69592
69593 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetScaling(void * jarg1, int jarg2) {
69594   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69595   Dali::Toolkit::Alignment::Scaling arg2 ;
69596
69597   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69598   arg2 = (Dali::Toolkit::Alignment::Scaling)jarg2;
69599   {
69600     try {
69601       (arg1)->SetScaling(arg2);
69602     } catch (std::out_of_range& e) {
69603       {
69604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69605       };
69606     } catch (std::exception& e) {
69607       {
69608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69609       };
69610     } catch (Dali::DaliException e) {
69611       {
69612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69613       };
69614     } catch (...) {
69615       {
69616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69617       };
69618     }
69619   }
69620
69621 }
69622
69623
69624 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetScaling(void * jarg1) {
69625   int jresult ;
69626   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69627   Dali::Toolkit::Alignment::Scaling result;
69628
69629   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69630   {
69631     try {
69632       result = (Dali::Toolkit::Alignment::Scaling)((Dali::Toolkit::Alignment const *)arg1)->GetScaling();
69633     } catch (std::out_of_range& e) {
69634       {
69635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69636       };
69637     } catch (std::exception& e) {
69638       {
69639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69640       };
69641     } catch (Dali::DaliException e) {
69642       {
69643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69644       };
69645     } catch (...) {
69646       {
69647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69648       };
69649     }
69650   }
69651
69652   jresult = (int)result;
69653   return jresult;
69654 }
69655
69656
69657 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetPadding(void * jarg1, void * jarg2) {
69658   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69659   Dali::Toolkit::Alignment::Padding *arg2 = 0 ;
69660
69661   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69662   arg2 = (Dali::Toolkit::Alignment::Padding *)jarg2;
69663   if (!arg2) {
69664     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment::Padding const & type is null", 0);
69665     return ;
69666   }
69667   {
69668     try {
69669       (arg1)->SetPadding((Dali::Toolkit::Alignment::Padding const &)*arg2);
69670     } catch (std::out_of_range& e) {
69671       {
69672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69673       };
69674     } catch (std::exception& e) {
69675       {
69676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69677       };
69678     } catch (Dali::DaliException e) {
69679       {
69680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69681       };
69682     } catch (...) {
69683       {
69684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69685       };
69686     }
69687   }
69688
69689 }
69690
69691
69692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_GetPadding(void * jarg1) {
69693   void * jresult ;
69694   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69695   Dali::Toolkit::Alignment::Padding *result = 0 ;
69696
69697   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69698   {
69699     try {
69700       result = (Dali::Toolkit::Alignment::Padding *) &((Dali::Toolkit::Alignment const *)arg1)->GetPadding();
69701     } catch (std::out_of_range& e) {
69702       {
69703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69704       };
69705     } catch (std::exception& e) {
69706       {
69707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69708       };
69709     } catch (Dali::DaliException e) {
69710       {
69711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69712       };
69713     } catch (...) {
69714       {
69715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69716       };
69717     }
69718   }
69719
69720   jresult = (void *)result;
69721   return jresult;
69722 }
69723
69724
69725 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_Assign(void * jarg1, void * jarg2) {
69726   void * jresult ;
69727   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69728   Dali::Toolkit::Alignment *arg2 = 0 ;
69729   Dali::Toolkit::Alignment *result = 0 ;
69730
69731   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69732   arg2 = (Dali::Toolkit::Alignment *)jarg2;
69733   if (!arg2) {
69734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
69735     return 0;
69736   }
69737   {
69738     try {
69739       result = (Dali::Toolkit::Alignment *) &(arg1)->operator =((Dali::Toolkit::Alignment const &)*arg2);
69740     } catch (std::out_of_range& e) {
69741       {
69742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69743       };
69744     } catch (std::exception& e) {
69745       {
69746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69747       };
69748     } catch (Dali::DaliException e) {
69749       {
69750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69751       };
69752     } catch (...) {
69753       {
69754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69755       };
69756     }
69757   }
69758
69759   jresult = (void *)result;
69760   return jresult;
69761 }
69762
69763
69764 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_DISABLED_get() {
69765   int jresult ;
69766   int result;
69767
69768   result = (int)Dali::Toolkit::Button::Property::DISABLED;
69769   jresult = (int)result;
69770   return jresult;
69771 }
69772
69773
69774 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_AUTO_REPEATING_get() {
69775   int jresult ;
69776   int result;
69777
69778   result = (int)Dali::Toolkit::Button::Property::AUTO_REPEATING;
69779   jresult = (int)result;
69780   return jresult;
69781 }
69782
69783
69784 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_INITIAL_AUTO_REPEATING_DELAY_get() {
69785   int jresult ;
69786   int result;
69787
69788   result = (int)Dali::Toolkit::Button::Property::INITIAL_AUTO_REPEATING_DELAY;
69789   jresult = (int)result;
69790   return jresult;
69791 }
69792
69793
69794 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_NEXT_AUTO_REPEATING_DELAY_get() {
69795   int jresult ;
69796   int result;
69797
69798   result = (int)Dali::Toolkit::Button::Property::NEXT_AUTO_REPEATING_DELAY;
69799   jresult = (int)result;
69800   return jresult;
69801 }
69802
69803
69804 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_TOGGLABLE_get() {
69805   int jresult ;
69806   int result;
69807
69808   result = (int)Dali::Toolkit::Button::Property::TOGGLABLE;
69809   jresult = (int)result;
69810   return jresult;
69811 }
69812
69813
69814 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_get() {
69815   int jresult ;
69816   int result;
69817
69818   result = (int)Dali::Toolkit::Button::Property::SELECTED;
69819   jresult = (int)result;
69820   return jresult;
69821 }
69822
69823
69824 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_UNSELECTED_COLOR_get() {
69825   int jresult ;
69826   int result;
69827
69828   result = (int)Dali::Toolkit::Button::Property::UNSELECTED_COLOR;
69829   jresult = (int)result;
69830   return jresult;
69831 }
69832
69833
69834 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_COLOR_get() {
69835   int jresult ;
69836   int result;
69837
69838   result = (int)Dali::Toolkit::Button::Property::SELECTED_COLOR;
69839   jresult = (int)result;
69840   return jresult;
69841 }
69842
69843
69844 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_get() {
69845   int jresult ;
69846   int result;
69847
69848   result = (int)Dali::Toolkit::Button::Property::LABEL;
69849   jresult = (int)result;
69850   return jresult;
69851 }
69852
69853
69854 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_TEXT_get() {
69855   int jresult ;
69856   int result;
69857
69858   result = (int)Dali::Toolkit::Button::Property::LABEL_TEXT;
69859   jresult = (int)result;
69860   return jresult;
69861 }
69862
69863
69864 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button_Property() {
69865   void * jresult ;
69866   Dali::Toolkit::Button::Property *result = 0 ;
69867
69868   {
69869     try {
69870       result = (Dali::Toolkit::Button::Property *)new Dali::Toolkit::Button::Property();
69871     } catch (std::out_of_range& e) {
69872       {
69873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69874       };
69875     } catch (std::exception& e) {
69876       {
69877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69878       };
69879     } catch (Dali::DaliException e) {
69880       {
69881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69882       };
69883     } catch (...) {
69884       {
69885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69886       };
69887     }
69888   }
69889
69890   jresult = (void *)result;
69891   return jresult;
69892 }
69893
69894
69895 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button_Property(void * jarg1) {
69896   Dali::Toolkit::Button::Property *arg1 = (Dali::Toolkit::Button::Property *) 0 ;
69897
69898   arg1 = (Dali::Toolkit::Button::Property *)jarg1;
69899   {
69900     try {
69901       delete arg1;
69902     } catch (std::out_of_range& e) {
69903       {
69904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69905       };
69906     } catch (std::exception& e) {
69907       {
69908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69909       };
69910     } catch (Dali::DaliException e) {
69911       {
69912         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69913       };
69914     } catch (...) {
69915       {
69916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69917       };
69918     }
69919   }
69920
69921 }
69922
69923
69924 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_0() {
69925   void * jresult ;
69926   Dali::Toolkit::Button *result = 0 ;
69927
69928   {
69929     try {
69930       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button();
69931     } catch (std::out_of_range& e) {
69932       {
69933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69934       };
69935     } catch (std::exception& e) {
69936       {
69937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69938       };
69939     } catch (Dali::DaliException e) {
69940       {
69941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69942       };
69943     } catch (...) {
69944       {
69945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69946       };
69947     }
69948   }
69949
69950   jresult = (void *)result;
69951   return jresult;
69952 }
69953
69954
69955 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_1(void * jarg1) {
69956   void * jresult ;
69957   Dali::Toolkit::Button *arg1 = 0 ;
69958   Dali::Toolkit::Button *result = 0 ;
69959
69960   arg1 = (Dali::Toolkit::Button *)jarg1;
69961   if (!arg1) {
69962     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
69963     return 0;
69964   }
69965   {
69966     try {
69967       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button((Dali::Toolkit::Button const &)*arg1);
69968     } catch (std::out_of_range& e) {
69969       {
69970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69971       };
69972     } catch (std::exception& e) {
69973       {
69974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69975       };
69976     } catch (Dali::DaliException e) {
69977       {
69978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69979       };
69980     } catch (...) {
69981       {
69982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69983       };
69984     }
69985   }
69986
69987   jresult = (void *)result;
69988   return jresult;
69989 }
69990
69991
69992 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_Assign(void * jarg1, void * jarg2) {
69993   void * jresult ;
69994   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69995   Dali::Toolkit::Button *arg2 = 0 ;
69996   Dali::Toolkit::Button *result = 0 ;
69997
69998   arg1 = (Dali::Toolkit::Button *)jarg1;
69999   arg2 = (Dali::Toolkit::Button *)jarg2;
70000   if (!arg2) {
70001     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
70002     return 0;
70003   }
70004   {
70005     try {
70006       result = (Dali::Toolkit::Button *) &(arg1)->operator =((Dali::Toolkit::Button const &)*arg2);
70007     } catch (std::out_of_range& e) {
70008       {
70009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70010       };
70011     } catch (std::exception& e) {
70012       {
70013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70014       };
70015     } catch (Dali::DaliException e) {
70016       {
70017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70018       };
70019     } catch (...) {
70020       {
70021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70022       };
70023     }
70024   }
70025
70026   jresult = (void *)result;
70027   return jresult;
70028 }
70029
70030
70031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_DownCast(void * jarg1) {
70032   void * jresult ;
70033   Dali::BaseHandle arg1 ;
70034   Dali::BaseHandle *argp1 ;
70035   Dali::Toolkit::Button result;
70036
70037   argp1 = (Dali::BaseHandle *)jarg1;
70038   if (!argp1) {
70039     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
70040     return 0;
70041   }
70042   arg1 = *argp1;
70043   {
70044     try {
70045       result = Dali::Toolkit::Button::DownCast(arg1);
70046     } catch (std::out_of_range& e) {
70047       {
70048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70049       };
70050     } catch (std::exception& e) {
70051       {
70052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70053       };
70054     } catch (Dali::DaliException e) {
70055       {
70056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70057       };
70058     } catch (...) {
70059       {
70060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70061       };
70062     }
70063   }
70064
70065   jresult = new Dali::Toolkit::Button((const Dali::Toolkit::Button &)result);
70066   return jresult;
70067 }
70068
70069
70070 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button(void * jarg1) {
70071   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70072
70073   arg1 = (Dali::Toolkit::Button *)jarg1;
70074   {
70075     try {
70076       delete arg1;
70077     } catch (std::out_of_range& e) {
70078       {
70079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70080       };
70081     } catch (std::exception& e) {
70082       {
70083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70084       };
70085     } catch (Dali::DaliException e) {
70086       {
70087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70088       };
70089     } catch (...) {
70090       {
70091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70092       };
70093     }
70094   }
70095
70096 }
70097
70098
70099 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsDisabled(void * jarg1) {
70100   unsigned int jresult ;
70101   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70102   bool result;
70103
70104   arg1 = (Dali::Toolkit::Button *)jarg1;
70105   {
70106     try {
70107       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsDisabled();
70108     } catch (std::out_of_range& e) {
70109       {
70110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70111       };
70112     } catch (std::exception& e) {
70113       {
70114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70115       };
70116     } catch (Dali::DaliException e) {
70117       {
70118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70119       };
70120     } catch (...) {
70121       {
70122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70123       };
70124     }
70125   }
70126
70127   jresult = result;
70128   return jresult;
70129 }
70130
70131
70132 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsAutoRepeating(void * jarg1) {
70133   unsigned int jresult ;
70134   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70135   bool result;
70136
70137   arg1 = (Dali::Toolkit::Button *)jarg1;
70138   {
70139     try {
70140       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsAutoRepeating();
70141     } catch (std::out_of_range& e) {
70142       {
70143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70144       };
70145     } catch (std::exception& e) {
70146       {
70147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70148       };
70149     } catch (Dali::DaliException e) {
70150       {
70151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70152       };
70153     } catch (...) {
70154       {
70155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70156       };
70157     }
70158   }
70159
70160   jresult = result;
70161   return jresult;
70162 }
70163
70164
70165 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetInitialAutoRepeatingDelay(void * jarg1) {
70166   float jresult ;
70167   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70168   float result;
70169
70170   arg1 = (Dali::Toolkit::Button *)jarg1;
70171   {
70172     try {
70173       result = (float)((Dali::Toolkit::Button const *)arg1)->GetInitialAutoRepeatingDelay();
70174     } catch (std::out_of_range& e) {
70175       {
70176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70177       };
70178     } catch (std::exception& e) {
70179       {
70180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70181       };
70182     } catch (Dali::DaliException e) {
70183       {
70184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70185       };
70186     } catch (...) {
70187       {
70188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70189       };
70190     }
70191   }
70192
70193   jresult = result;
70194   return jresult;
70195 }
70196
70197
70198 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetNextAutoRepeatingDelay(void * jarg1) {
70199   float jresult ;
70200   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70201   float result;
70202
70203   arg1 = (Dali::Toolkit::Button *)jarg1;
70204   {
70205     try {
70206       result = (float)((Dali::Toolkit::Button const *)arg1)->GetNextAutoRepeatingDelay();
70207     } catch (std::out_of_range& e) {
70208       {
70209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70210       };
70211     } catch (std::exception& e) {
70212       {
70213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70214       };
70215     } catch (Dali::DaliException e) {
70216       {
70217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70218       };
70219     } catch (...) {
70220       {
70221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70222       };
70223     }
70224   }
70225
70226   jresult = result;
70227   return jresult;
70228 }
70229
70230
70231 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsTogglableButton(void * jarg1) {
70232   unsigned int jresult ;
70233   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70234   bool result;
70235
70236   arg1 = (Dali::Toolkit::Button *)jarg1;
70237   {
70238     try {
70239       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsTogglableButton();
70240     } catch (std::out_of_range& e) {
70241       {
70242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70243       };
70244     } catch (std::exception& e) {
70245       {
70246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70247       };
70248     } catch (Dali::DaliException e) {
70249       {
70250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70251       };
70252     } catch (...) {
70253       {
70254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70255       };
70256     }
70257   }
70258
70259   jresult = result;
70260   return jresult;
70261 }
70262
70263
70264 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsSelected(void * jarg1) {
70265   unsigned int jresult ;
70266   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70267   bool result;
70268
70269   arg1 = (Dali::Toolkit::Button *)jarg1;
70270   {
70271     try {
70272       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsSelected();
70273     } catch (std::out_of_range& e) {
70274       {
70275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70276       };
70277     } catch (std::exception& e) {
70278       {
70279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70280       };
70281     } catch (Dali::DaliException e) {
70282       {
70283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70284       };
70285     } catch (...) {
70286       {
70287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70288       };
70289     }
70290   }
70291
70292   jresult = result;
70293   return jresult;
70294 }
70295
70296
70297 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetAnimationTime(void * jarg1) {
70298   float jresult ;
70299   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70300   float result;
70301
70302   arg1 = (Dali::Toolkit::Button *)jarg1;
70303   {
70304     try {
70305       result = (float)((Dali::Toolkit::Button const *)arg1)->GetAnimationTime();
70306     } catch (std::out_of_range& e) {
70307       {
70308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70309       };
70310     } catch (std::exception& e) {
70311       {
70312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70313       };
70314     } catch (Dali::DaliException e) {
70315       {
70316         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70317       };
70318     } catch (...) {
70319       {
70320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70321       };
70322     }
70323   }
70324
70325   jresult = result;
70326   return jresult;
70327 }
70328
70329
70330 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Button_GetLabelText(void * jarg1) {
70331   char * jresult ;
70332   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70333   std::string result;
70334
70335   arg1 = (Dali::Toolkit::Button *)jarg1;
70336   {
70337     try {
70338       result = ((Dali::Toolkit::Button const *)arg1)->GetLabelText();
70339     } catch (std::out_of_range& e) {
70340       {
70341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70342       };
70343     } catch (std::exception& e) {
70344       {
70345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70346       };
70347     } catch (Dali::DaliException e) {
70348       {
70349         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70350       };
70351     } catch (...) {
70352       {
70353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70354       };
70355     }
70356   }
70357
70358   jresult = SWIG_csharp_string_callback((&result)->c_str());
70359   return jresult;
70360 }
70361
70362
70363 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetLabel(void * jarg1, void * jarg2) {
70364   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70365   Dali::Actor arg2 ;
70366   Dali::Actor *argp2 ;
70367
70368   arg1 = (Dali::Toolkit::Button *)jarg1;
70369   argp2 = (Dali::Actor *)jarg2;
70370   if (!argp2) {
70371     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70372     return ;
70373   }
70374   arg2 = *argp2;
70375   {
70376     try {
70377       (arg1)->SetLabel(arg2);
70378     } catch (std::out_of_range& e) {
70379       {
70380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70381       };
70382     } catch (std::exception& e) {
70383       {
70384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70385       };
70386     } catch (Dali::DaliException e) {
70387       {
70388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70389       };
70390     } catch (...) {
70391       {
70392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70393       };
70394     }
70395   }
70396
70397 }
70398
70399
70400 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetButtonImage(void * jarg1, void * jarg2) {
70401   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70402   Dali::Image arg2 ;
70403   Dali::Image *argp2 ;
70404
70405   arg1 = (Dali::Toolkit::Button *)jarg1;
70406   argp2 = (Dali::Image *)jarg2;
70407   if (!argp2) {
70408     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
70409     return ;
70410   }
70411   arg2 = *argp2;
70412   {
70413     try {
70414       (arg1)->SetButtonImage(arg2);
70415     } catch (std::out_of_range& e) {
70416       {
70417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70418       };
70419     } catch (std::exception& e) {
70420       {
70421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70422       };
70423     } catch (Dali::DaliException e) {
70424       {
70425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70426       };
70427     } catch (...) {
70428       {
70429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70430       };
70431     }
70432   }
70433
70434 }
70435
70436
70437 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetSelectedImage(void * jarg1, void * jarg2) {
70438   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70439   Dali::Image arg2 ;
70440   Dali::Image *argp2 ;
70441
70442   arg1 = (Dali::Toolkit::Button *)jarg1;
70443   argp2 = (Dali::Image *)jarg2;
70444   if (!argp2) {
70445     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
70446     return ;
70447   }
70448   arg2 = *argp2;
70449   {
70450     try {
70451       (arg1)->SetSelectedImage(arg2);
70452     } catch (std::out_of_range& e) {
70453       {
70454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70455       };
70456     } catch (std::exception& e) {
70457       {
70458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70459       };
70460     } catch (Dali::DaliException e) {
70461       {
70462         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70463       };
70464     } catch (...) {
70465       {
70466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70467       };
70468     }
70469   }
70470
70471 }
70472
70473
70474 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetButtonImage(void * jarg1) {
70475   void * jresult ;
70476   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70477   Dali::Actor result;
70478
70479   arg1 = (Dali::Toolkit::Button *)jarg1;
70480   {
70481     try {
70482       result = ((Dali::Toolkit::Button const *)arg1)->GetButtonImage();
70483     } catch (std::out_of_range& e) {
70484       {
70485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70486       };
70487     } catch (std::exception& e) {
70488       {
70489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70490       };
70491     } catch (Dali::DaliException e) {
70492       {
70493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70494       };
70495     } catch (...) {
70496       {
70497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70498       };
70499     }
70500   }
70501
70502   jresult = new Dali::Actor((const Dali::Actor &)result);
70503   return jresult;
70504 }
70505
70506
70507 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetSelectedImage(void * jarg1) {
70508   void * jresult ;
70509   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70510   Dali::Actor result;
70511
70512   arg1 = (Dali::Toolkit::Button *)jarg1;
70513   {
70514     try {
70515       result = ((Dali::Toolkit::Button const *)arg1)->GetSelectedImage();
70516     } catch (std::out_of_range& e) {
70517       {
70518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70519       };
70520     } catch (std::exception& e) {
70521       {
70522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70523       };
70524     } catch (Dali::DaliException e) {
70525       {
70526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70527       };
70528     } catch (...) {
70529       {
70530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70531       };
70532     }
70533   }
70534
70535   jresult = new Dali::Actor((const Dali::Actor &)result);
70536   return jresult;
70537 }
70538
70539
70540 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_PressedSignal(void * jarg1) {
70541   void * jresult ;
70542   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70543   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
70544
70545   arg1 = (Dali::Toolkit::Button *)jarg1;
70546   {
70547     try {
70548       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->PressedSignal();
70549     } catch (std::out_of_range& e) {
70550       {
70551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70552       };
70553     } catch (std::exception& e) {
70554       {
70555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70556       };
70557     } catch (Dali::DaliException e) {
70558       {
70559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70560       };
70561     } catch (...) {
70562       {
70563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70564       };
70565     }
70566   }
70567
70568   jresult = (void *)result;
70569   return jresult;
70570 }
70571
70572
70573 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ReleasedSignal(void * jarg1) {
70574   void * jresult ;
70575   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70576   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
70577
70578   arg1 = (Dali::Toolkit::Button *)jarg1;
70579   {
70580     try {
70581       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ReleasedSignal();
70582     } catch (std::out_of_range& e) {
70583       {
70584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70585       };
70586     } catch (std::exception& e) {
70587       {
70588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70589       };
70590     } catch (Dali::DaliException e) {
70591       {
70592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70593       };
70594     } catch (...) {
70595       {
70596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70597       };
70598     }
70599   }
70600
70601   jresult = (void *)result;
70602   return jresult;
70603 }
70604
70605
70606 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ClickedSignal(void * jarg1) {
70607   void * jresult ;
70608   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70609   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
70610
70611   arg1 = (Dali::Toolkit::Button *)jarg1;
70612   {
70613     try {
70614       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ClickedSignal();
70615     } catch (std::out_of_range& e) {
70616       {
70617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70618       };
70619     } catch (std::exception& e) {
70620       {
70621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70622       };
70623     } catch (Dali::DaliException e) {
70624       {
70625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70626       };
70627     } catch (...) {
70628       {
70629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70630       };
70631     }
70632   }
70633
70634   jresult = (void *)result;
70635   return jresult;
70636 }
70637
70638
70639 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_StateChangedSignal(void * jarg1) {
70640   void * jresult ;
70641   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70642   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
70643
70644   arg1 = (Dali::Toolkit::Button *)jarg1;
70645   {
70646     try {
70647       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->StateChangedSignal();
70648     } catch (std::out_of_range& e) {
70649       {
70650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70651       };
70652     } catch (std::exception& e) {
70653       {
70654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70655       };
70656     } catch (Dali::DaliException e) {
70657       {
70658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70659       };
70660     } catch (...) {
70661       {
70662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70663       };
70664     }
70665   }
70666
70667   jresult = (void *)result;
70668   return jresult;
70669 }
70670
70671
70672 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_0() {
70673   void * jresult ;
70674   Dali::Toolkit::CheckBoxButton *result = 0 ;
70675
70676   {
70677     try {
70678       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton();
70679     } catch (std::out_of_range& e) {
70680       {
70681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70682       };
70683     } catch (std::exception& e) {
70684       {
70685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70686       };
70687     } catch (Dali::DaliException e) {
70688       {
70689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70690       };
70691     } catch (...) {
70692       {
70693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70694       };
70695     }
70696   }
70697
70698   jresult = (void *)result;
70699   return jresult;
70700 }
70701
70702
70703 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_1(void * jarg1) {
70704   void * jresult ;
70705   Dali::Toolkit::CheckBoxButton *arg1 = 0 ;
70706   Dali::Toolkit::CheckBoxButton *result = 0 ;
70707
70708   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
70709   if (!arg1) {
70710     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
70711     return 0;
70712   }
70713   {
70714     try {
70715       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton((Dali::Toolkit::CheckBoxButton const &)*arg1);
70716     } catch (std::out_of_range& e) {
70717       {
70718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70719       };
70720     } catch (std::exception& e) {
70721       {
70722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70723       };
70724     } catch (Dali::DaliException e) {
70725       {
70726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70727       };
70728     } catch (...) {
70729       {
70730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70731       };
70732     }
70733   }
70734
70735   jresult = (void *)result;
70736   return jresult;
70737 }
70738
70739
70740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_Assign(void * jarg1, void * jarg2) {
70741   void * jresult ;
70742   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
70743   Dali::Toolkit::CheckBoxButton *arg2 = 0 ;
70744   Dali::Toolkit::CheckBoxButton *result = 0 ;
70745
70746   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
70747   arg2 = (Dali::Toolkit::CheckBoxButton *)jarg2;
70748   if (!arg2) {
70749     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
70750     return 0;
70751   }
70752   {
70753     try {
70754       result = (Dali::Toolkit::CheckBoxButton *) &(arg1)->operator =((Dali::Toolkit::CheckBoxButton const &)*arg2);
70755     } catch (std::out_of_range& e) {
70756       {
70757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70758       };
70759     } catch (std::exception& e) {
70760       {
70761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70762       };
70763     } catch (Dali::DaliException e) {
70764       {
70765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70766       };
70767     } catch (...) {
70768       {
70769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70770       };
70771     }
70772   }
70773
70774   jresult = (void *)result;
70775   return jresult;
70776 }
70777
70778
70779 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CheckBoxButton(void * jarg1) {
70780   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
70781
70782   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
70783   {
70784     try {
70785       delete arg1;
70786     } catch (std::out_of_range& e) {
70787       {
70788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70789       };
70790     } catch (std::exception& e) {
70791       {
70792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70793       };
70794     } catch (Dali::DaliException e) {
70795       {
70796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70797       };
70798     } catch (...) {
70799       {
70800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70801       };
70802     }
70803   }
70804
70805 }
70806
70807
70808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_New() {
70809   void * jresult ;
70810   Dali::Toolkit::CheckBoxButton result;
70811
70812   {
70813     try {
70814       result = Dali::Toolkit::CheckBoxButton::New();
70815     } catch (std::out_of_range& e) {
70816       {
70817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70818       };
70819     } catch (std::exception& e) {
70820       {
70821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70822       };
70823     } catch (Dali::DaliException e) {
70824       {
70825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70826       };
70827     } catch (...) {
70828       {
70829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70830       };
70831     }
70832   }
70833
70834   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
70835   return jresult;
70836 }
70837
70838
70839 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_DownCast(void * jarg1) {
70840   void * jresult ;
70841   Dali::BaseHandle arg1 ;
70842   Dali::BaseHandle *argp1 ;
70843   Dali::Toolkit::CheckBoxButton result;
70844
70845   argp1 = (Dali::BaseHandle *)jarg1;
70846   if (!argp1) {
70847     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
70848     return 0;
70849   }
70850   arg1 = *argp1;
70851   {
70852     try {
70853       result = Dali::Toolkit::CheckBoxButton::DownCast(arg1);
70854     } catch (std::out_of_range& e) {
70855       {
70856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70857       };
70858     } catch (std::exception& e) {
70859       {
70860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70861       };
70862     } catch (Dali::DaliException e) {
70863       {
70864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70865       };
70866     } catch (...) {
70867       {
70868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70869       };
70870     }
70871   }
70872
70873   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
70874   return jresult;
70875 }
70876
70877
70878 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_UNSELECTED_ICON_get() {
70879   int jresult ;
70880   int result;
70881
70882   result = (int)Dali::Toolkit::PushButton::Property::UNSELECTED_ICON;
70883   jresult = (int)result;
70884   return jresult;
70885 }
70886
70887
70888 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_SELECTED_ICON_get() {
70889   int jresult ;
70890   int result;
70891
70892   result = (int)Dali::Toolkit::PushButton::Property::SELECTED_ICON;
70893   jresult = (int)result;
70894   return jresult;
70895 }
70896
70897
70898 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_ALIGNMENT_get() {
70899   int jresult ;
70900   int result;
70901
70902   result = (int)Dali::Toolkit::PushButton::Property::ICON_ALIGNMENT;
70903   jresult = (int)result;
70904   return jresult;
70905 }
70906
70907
70908 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_LABEL_PADDING_get() {
70909   int jresult ;
70910   int result;
70911
70912   result = (int)Dali::Toolkit::PushButton::Property::LABEL_PADDING;
70913   jresult = (int)result;
70914   return jresult;
70915 }
70916
70917
70918 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_PADDING_get() {
70919   int jresult ;
70920   int result;
70921
70922   result = (int)Dali::Toolkit::PushButton::Property::ICON_PADDING;
70923   jresult = (int)result;
70924   return jresult;
70925 }
70926
70927
70928 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton_Property() {
70929   void * jresult ;
70930   Dali::Toolkit::PushButton::Property *result = 0 ;
70931
70932   {
70933     try {
70934       result = (Dali::Toolkit::PushButton::Property *)new Dali::Toolkit::PushButton::Property();
70935     } catch (std::out_of_range& e) {
70936       {
70937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70938       };
70939     } catch (std::exception& e) {
70940       {
70941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70942       };
70943     } catch (Dali::DaliException e) {
70944       {
70945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70946       };
70947     } catch (...) {
70948       {
70949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70950       };
70951     }
70952   }
70953
70954   jresult = (void *)result;
70955   return jresult;
70956 }
70957
70958
70959 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton_Property(void * jarg1) {
70960   Dali::Toolkit::PushButton::Property *arg1 = (Dali::Toolkit::PushButton::Property *) 0 ;
70961
70962   arg1 = (Dali::Toolkit::PushButton::Property *)jarg1;
70963   {
70964     try {
70965       delete arg1;
70966     } catch (std::out_of_range& e) {
70967       {
70968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70969       };
70970     } catch (std::exception& e) {
70971       {
70972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70973       };
70974     } catch (Dali::DaliException e) {
70975       {
70976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70977       };
70978     } catch (...) {
70979       {
70980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70981       };
70982     }
70983   }
70984
70985 }
70986
70987
70988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_0() {
70989   void * jresult ;
70990   Dali::Toolkit::PushButton *result = 0 ;
70991
70992   {
70993     try {
70994       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton();
70995     } catch (std::out_of_range& e) {
70996       {
70997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70998       };
70999     } catch (std::exception& e) {
71000       {
71001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71002       };
71003     } catch (Dali::DaliException e) {
71004       {
71005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71006       };
71007     } catch (...) {
71008       {
71009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71010       };
71011     }
71012   }
71013
71014   jresult = (void *)result;
71015   return jresult;
71016 }
71017
71018
71019 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_1(void * jarg1) {
71020   void * jresult ;
71021   Dali::Toolkit::PushButton *arg1 = 0 ;
71022   Dali::Toolkit::PushButton *result = 0 ;
71023
71024   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71025   if (!arg1) {
71026     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
71027     return 0;
71028   }
71029   {
71030     try {
71031       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton((Dali::Toolkit::PushButton const &)*arg1);
71032     } catch (std::out_of_range& e) {
71033       {
71034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71035       };
71036     } catch (std::exception& e) {
71037       {
71038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71039       };
71040     } catch (Dali::DaliException e) {
71041       {
71042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71043       };
71044     } catch (...) {
71045       {
71046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71047       };
71048     }
71049   }
71050
71051   jresult = (void *)result;
71052   return jresult;
71053 }
71054
71055
71056 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_Assign(void * jarg1, void * jarg2) {
71057   void * jresult ;
71058   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71059   Dali::Toolkit::PushButton *arg2 = 0 ;
71060   Dali::Toolkit::PushButton *result = 0 ;
71061
71062   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71063   arg2 = (Dali::Toolkit::PushButton *)jarg2;
71064   if (!arg2) {
71065     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
71066     return 0;
71067   }
71068   {
71069     try {
71070       result = (Dali::Toolkit::PushButton *) &(arg1)->operator =((Dali::Toolkit::PushButton const &)*arg2);
71071     } catch (std::out_of_range& e) {
71072       {
71073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71074       };
71075     } catch (std::exception& e) {
71076       {
71077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71078       };
71079     } catch (Dali::DaliException e) {
71080       {
71081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71082       };
71083     } catch (...) {
71084       {
71085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71086       };
71087     }
71088   }
71089
71090   jresult = (void *)result;
71091   return jresult;
71092 }
71093
71094
71095 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton(void * jarg1) {
71096   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71097
71098   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71099   {
71100     try {
71101       delete arg1;
71102     } catch (std::out_of_range& e) {
71103       {
71104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71105       };
71106     } catch (std::exception& e) {
71107       {
71108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71109       };
71110     } catch (Dali::DaliException e) {
71111       {
71112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71113       };
71114     } catch (...) {
71115       {
71116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71117       };
71118     }
71119   }
71120
71121 }
71122
71123
71124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_New() {
71125   void * jresult ;
71126   Dali::Toolkit::PushButton result;
71127
71128   {
71129     try {
71130       result = Dali::Toolkit::PushButton::New();
71131     } catch (std::out_of_range& e) {
71132       {
71133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71134       };
71135     } catch (std::exception& e) {
71136       {
71137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71138       };
71139     } catch (Dali::DaliException e) {
71140       {
71141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71142       };
71143     } catch (...) {
71144       {
71145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71146       };
71147     }
71148   }
71149
71150   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
71151   return jresult;
71152 }
71153
71154
71155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_DownCast(void * jarg1) {
71156   void * jresult ;
71157   Dali::BaseHandle arg1 ;
71158   Dali::BaseHandle *argp1 ;
71159   Dali::Toolkit::PushButton result;
71160
71161   argp1 = (Dali::BaseHandle *)jarg1;
71162   if (!argp1) {
71163     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
71164     return 0;
71165   }
71166   arg1 = *argp1;
71167   {
71168     try {
71169       result = Dali::Toolkit::PushButton::DownCast(arg1);
71170     } catch (std::out_of_range& e) {
71171       {
71172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71173       };
71174     } catch (std::exception& e) {
71175       {
71176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71177       };
71178     } catch (Dali::DaliException e) {
71179       {
71180         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71181       };
71182     } catch (...) {
71183       {
71184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71185       };
71186     }
71187   }
71188
71189   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
71190   return jresult;
71191 }
71192
71193
71194 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_0_0(void * jarg1, void * jarg2) {
71195   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71196   Dali::Image arg2 ;
71197   Dali::Image *argp2 ;
71198
71199   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71200   argp2 = (Dali::Image *)jarg2;
71201   if (!argp2) {
71202     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
71203     return ;
71204   }
71205   arg2 = *argp2;
71206   {
71207     try {
71208       (arg1)->SetButtonImage(arg2);
71209     } catch (std::out_of_range& e) {
71210       {
71211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71212       };
71213     } catch (std::exception& e) {
71214       {
71215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71216       };
71217     } catch (Dali::DaliException e) {
71218       {
71219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71220       };
71221     } catch (...) {
71222       {
71223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71224       };
71225     }
71226   }
71227
71228 }
71229
71230
71231 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_1(void * jarg1, void * jarg2) {
71232   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71233   Dali::Actor arg2 ;
71234   Dali::Actor *argp2 ;
71235
71236   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71237   argp2 = (Dali::Actor *)jarg2;
71238   if (!argp2) {
71239     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71240     return ;
71241   }
71242   arg2 = *argp2;
71243   {
71244     try {
71245       (arg1)->SetButtonImage(arg2);
71246     } catch (std::out_of_range& e) {
71247       {
71248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71249       };
71250     } catch (std::exception& e) {
71251       {
71252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71253       };
71254     } catch (Dali::DaliException e) {
71255       {
71256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71257       };
71258     } catch (...) {
71259       {
71260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71261       };
71262     }
71263   }
71264
71265 }
71266
71267
71268 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetBackgroundImage(void * jarg1, void * jarg2) {
71269   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71270   Dali::Actor arg2 ;
71271   Dali::Actor *argp2 ;
71272
71273   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71274   argp2 = (Dali::Actor *)jarg2;
71275   if (!argp2) {
71276     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71277     return ;
71278   }
71279   arg2 = *argp2;
71280   {
71281     try {
71282       (arg1)->SetBackgroundImage(arg2);
71283     } catch (std::out_of_range& e) {
71284       {
71285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71286       };
71287     } catch (std::exception& e) {
71288       {
71289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71290       };
71291     } catch (Dali::DaliException e) {
71292       {
71293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71294       };
71295     } catch (...) {
71296       {
71297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71298       };
71299     }
71300   }
71301
71302 }
71303
71304
71305 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_0_0(void * jarg1, void * jarg2) {
71306   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71307   Dali::Image arg2 ;
71308   Dali::Image *argp2 ;
71309
71310   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71311   argp2 = (Dali::Image *)jarg2;
71312   if (!argp2) {
71313     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
71314     return ;
71315   }
71316   arg2 = *argp2;
71317   {
71318     try {
71319       (arg1)->SetSelectedImage(arg2);
71320     } catch (std::out_of_range& e) {
71321       {
71322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71323       };
71324     } catch (std::exception& e) {
71325       {
71326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71327       };
71328     } catch (Dali::DaliException e) {
71329       {
71330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71331       };
71332     } catch (...) {
71333       {
71334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71335       };
71336     }
71337   }
71338
71339 }
71340
71341
71342 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_1(void * jarg1, void * jarg2) {
71343   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71344   Dali::Actor arg2 ;
71345   Dali::Actor *argp2 ;
71346
71347   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71348   argp2 = (Dali::Actor *)jarg2;
71349   if (!argp2) {
71350     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71351     return ;
71352   }
71353   arg2 = *argp2;
71354   {
71355     try {
71356       (arg1)->SetSelectedImage(arg2);
71357     } catch (std::out_of_range& e) {
71358       {
71359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71360       };
71361     } catch (std::exception& e) {
71362       {
71363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71364       };
71365     } catch (Dali::DaliException e) {
71366       {
71367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71368       };
71369     } catch (...) {
71370       {
71371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71372       };
71373     }
71374   }
71375
71376 }
71377
71378
71379 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedBackgroundImage(void * jarg1, void * jarg2) {
71380   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71381   Dali::Actor arg2 ;
71382   Dali::Actor *argp2 ;
71383
71384   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71385   argp2 = (Dali::Actor *)jarg2;
71386   if (!argp2) {
71387     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71388     return ;
71389   }
71390   arg2 = *argp2;
71391   {
71392     try {
71393       (arg1)->SetSelectedBackgroundImage(arg2);
71394     } catch (std::out_of_range& e) {
71395       {
71396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71397       };
71398     } catch (std::exception& e) {
71399       {
71400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71401       };
71402     } catch (Dali::DaliException e) {
71403       {
71404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71405       };
71406     } catch (...) {
71407       {
71408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71409       };
71410     }
71411   }
71412
71413 }
71414
71415
71416 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledBackgroundImage(void * jarg1, void * jarg2) {
71417   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71418   Dali::Actor arg2 ;
71419   Dali::Actor *argp2 ;
71420
71421   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71422   argp2 = (Dali::Actor *)jarg2;
71423   if (!argp2) {
71424     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71425     return ;
71426   }
71427   arg2 = *argp2;
71428   {
71429     try {
71430       (arg1)->SetDisabledBackgroundImage(arg2);
71431     } catch (std::out_of_range& e) {
71432       {
71433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71434       };
71435     } catch (std::exception& e) {
71436       {
71437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71438       };
71439     } catch (Dali::DaliException e) {
71440       {
71441         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71442       };
71443     } catch (...) {
71444       {
71445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71446       };
71447     }
71448   }
71449
71450 }
71451
71452
71453 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledImage(void * jarg1, void * jarg2) {
71454   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71455   Dali::Actor arg2 ;
71456   Dali::Actor *argp2 ;
71457
71458   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71459   argp2 = (Dali::Actor *)jarg2;
71460   if (!argp2) {
71461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71462     return ;
71463   }
71464   arg2 = *argp2;
71465   {
71466     try {
71467       (arg1)->SetDisabledImage(arg2);
71468     } catch (std::out_of_range& e) {
71469       {
71470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71471       };
71472     } catch (std::exception& e) {
71473       {
71474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71475       };
71476     } catch (Dali::DaliException e) {
71477       {
71478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71479       };
71480     } catch (...) {
71481       {
71482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71483       };
71484     }
71485   }
71486
71487 }
71488
71489
71490 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledSelectedImage(void * jarg1, void * jarg2) {
71491   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71492   Dali::Actor arg2 ;
71493   Dali::Actor *argp2 ;
71494
71495   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71496   argp2 = (Dali::Actor *)jarg2;
71497   if (!argp2) {
71498     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71499     return ;
71500   }
71501   arg2 = *argp2;
71502   {
71503     try {
71504       (arg1)->SetDisabledSelectedImage(arg2);
71505     } catch (std::out_of_range& e) {
71506       {
71507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71508       };
71509     } catch (std::exception& e) {
71510       {
71511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71512       };
71513     } catch (Dali::DaliException e) {
71514       {
71515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71516       };
71517     } catch (...) {
71518       {
71519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71520       };
71521     }
71522   }
71523
71524 }
71525
71526
71527 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_0() {
71528   void * jresult ;
71529   Dali::Toolkit::RadioButton *result = 0 ;
71530
71531   {
71532     try {
71533       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton();
71534     } catch (std::out_of_range& e) {
71535       {
71536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71537       };
71538     } catch (std::exception& e) {
71539       {
71540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71541       };
71542     } catch (Dali::DaliException e) {
71543       {
71544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71545       };
71546     } catch (...) {
71547       {
71548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71549       };
71550     }
71551   }
71552
71553   jresult = (void *)result;
71554   return jresult;
71555 }
71556
71557
71558 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_1(void * jarg1) {
71559   void * jresult ;
71560   Dali::Toolkit::RadioButton *arg1 = 0 ;
71561   Dali::Toolkit::RadioButton *result = 0 ;
71562
71563   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
71564   if (!arg1) {
71565     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
71566     return 0;
71567   }
71568   {
71569     try {
71570       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton((Dali::Toolkit::RadioButton const &)*arg1);
71571     } catch (std::out_of_range& e) {
71572       {
71573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71574       };
71575     } catch (std::exception& e) {
71576       {
71577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71578       };
71579     } catch (Dali::DaliException e) {
71580       {
71581         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71582       };
71583     } catch (...) {
71584       {
71585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71586       };
71587     }
71588   }
71589
71590   jresult = (void *)result;
71591   return jresult;
71592 }
71593
71594
71595 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_Assign(void * jarg1, void * jarg2) {
71596   void * jresult ;
71597   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
71598   Dali::Toolkit::RadioButton *arg2 = 0 ;
71599   Dali::Toolkit::RadioButton *result = 0 ;
71600
71601   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
71602   arg2 = (Dali::Toolkit::RadioButton *)jarg2;
71603   if (!arg2) {
71604     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
71605     return 0;
71606   }
71607   {
71608     try {
71609       result = (Dali::Toolkit::RadioButton *) &(arg1)->operator =((Dali::Toolkit::RadioButton const &)*arg2);
71610     } catch (std::out_of_range& e) {
71611       {
71612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71613       };
71614     } catch (std::exception& e) {
71615       {
71616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71617       };
71618     } catch (Dali::DaliException e) {
71619       {
71620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71621       };
71622     } catch (...) {
71623       {
71624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71625       };
71626     }
71627   }
71628
71629   jresult = (void *)result;
71630   return jresult;
71631 }
71632
71633
71634 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RadioButton(void * jarg1) {
71635   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
71636
71637   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
71638   {
71639     try {
71640       delete arg1;
71641     } catch (std::out_of_range& e) {
71642       {
71643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71644       };
71645     } catch (std::exception& e) {
71646       {
71647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71648       };
71649     } catch (Dali::DaliException e) {
71650       {
71651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71652       };
71653     } catch (...) {
71654       {
71655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71656       };
71657     }
71658   }
71659
71660 }
71661
71662
71663 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_0() {
71664   void * jresult ;
71665   Dali::Toolkit::RadioButton result;
71666
71667   {
71668     try {
71669       result = Dali::Toolkit::RadioButton::New();
71670     } catch (std::out_of_range& e) {
71671       {
71672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71673       };
71674     } catch (std::exception& e) {
71675       {
71676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71677       };
71678     } catch (Dali::DaliException e) {
71679       {
71680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71681       };
71682     } catch (...) {
71683       {
71684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71685       };
71686     }
71687   }
71688
71689   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
71690   return jresult;
71691 }
71692
71693
71694 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_1(char * jarg1) {
71695   void * jresult ;
71696   std::string *arg1 = 0 ;
71697   Dali::Toolkit::RadioButton result;
71698
71699   if (!jarg1) {
71700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
71701     return 0;
71702   }
71703   std::string arg1_str(jarg1);
71704   arg1 = &arg1_str;
71705   {
71706     try {
71707       result = Dali::Toolkit::RadioButton::New((std::string const &)*arg1);
71708     } catch (std::out_of_range& e) {
71709       {
71710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71711       };
71712     } catch (std::exception& e) {
71713       {
71714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71715       };
71716     } catch (Dali::DaliException e) {
71717       {
71718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71719       };
71720     } catch (...) {
71721       {
71722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71723       };
71724     }
71725   }
71726
71727   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
71728
71729   //argout typemap for const std::string&
71730
71731   return jresult;
71732 }
71733
71734
71735 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_DownCast(void * jarg1) {
71736   void * jresult ;
71737   Dali::BaseHandle arg1 ;
71738   Dali::BaseHandle *argp1 ;
71739   Dali::Toolkit::RadioButton result;
71740
71741   argp1 = (Dali::BaseHandle *)jarg1;
71742   if (!argp1) {
71743     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
71744     return 0;
71745   }
71746   arg1 = *argp1;
71747   {
71748     try {
71749       result = Dali::Toolkit::RadioButton::DownCast(arg1);
71750     } catch (std::out_of_range& e) {
71751       {
71752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71753       };
71754     } catch (std::exception& e) {
71755       {
71756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71757       };
71758     } catch (Dali::DaliException e) {
71759       {
71760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71761       };
71762     } catch (...) {
71763       {
71764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71765       };
71766     }
71767   }
71768
71769   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
71770   return jresult;
71771 }
71772
71773
71774 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_CONTENT_DIRECTION_get() {
71775   int jresult ;
71776   int result;
71777
71778   result = (int)Dali::Toolkit::FlexContainer::Property::CONTENT_DIRECTION;
71779   jresult = (int)result;
71780   return jresult;
71781 }
71782
71783
71784 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_DIRECTION_get() {
71785   int jresult ;
71786   int result;
71787
71788   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_DIRECTION;
71789   jresult = (int)result;
71790   return jresult;
71791 }
71792
71793
71794 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_WRAP_get() {
71795   int jresult ;
71796   int result;
71797
71798   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_WRAP;
71799   jresult = (int)result;
71800   return jresult;
71801 }
71802
71803
71804 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_JUSTIFY_CONTENT_get() {
71805   int jresult ;
71806   int result;
71807
71808   result = (int)Dali::Toolkit::FlexContainer::Property::JUSTIFY_CONTENT;
71809   jresult = (int)result;
71810   return jresult;
71811 }
71812
71813
71814 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_ITEMS_get() {
71815   int jresult ;
71816   int result;
71817
71818   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_ITEMS;
71819   jresult = (int)result;
71820   return jresult;
71821 }
71822
71823
71824 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_CONTENT_get() {
71825   int jresult ;
71826   int result;
71827
71828   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_CONTENT;
71829   jresult = (int)result;
71830   return jresult;
71831 }
71832
71833
71834 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_Property() {
71835   void * jresult ;
71836   Dali::Toolkit::FlexContainer::Property *result = 0 ;
71837
71838   {
71839     try {
71840       result = (Dali::Toolkit::FlexContainer::Property *)new Dali::Toolkit::FlexContainer::Property();
71841     } catch (std::out_of_range& e) {
71842       {
71843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71844       };
71845     } catch (std::exception& e) {
71846       {
71847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71848       };
71849     } catch (Dali::DaliException e) {
71850       {
71851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71852       };
71853     } catch (...) {
71854       {
71855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71856       };
71857     }
71858   }
71859
71860   jresult = (void *)result;
71861   return jresult;
71862 }
71863
71864
71865 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_Property(void * jarg1) {
71866   Dali::Toolkit::FlexContainer::Property *arg1 = (Dali::Toolkit::FlexContainer::Property *) 0 ;
71867
71868   arg1 = (Dali::Toolkit::FlexContainer::Property *)jarg1;
71869   {
71870     try {
71871       delete arg1;
71872     } catch (std::out_of_range& e) {
71873       {
71874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71875       };
71876     } catch (std::exception& e) {
71877       {
71878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71879       };
71880     } catch (Dali::DaliException e) {
71881       {
71882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71883       };
71884     } catch (...) {
71885       {
71886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71887       };
71888     }
71889   }
71890
71891 }
71892
71893
71894 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_get() {
71895   int jresult ;
71896   int result;
71897
71898   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX;
71899   jresult = (int)result;
71900   return jresult;
71901 }
71902
71903
71904 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_ALIGN_SELF_get() {
71905   int jresult ;
71906   int result;
71907
71908   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::ALIGN_SELF;
71909   jresult = (int)result;
71910   return jresult;
71911 }
71912
71913
71914 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_MARGIN_get() {
71915   int jresult ;
71916   int result;
71917
71918   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX_MARGIN;
71919   jresult = (int)result;
71920   return jresult;
71921 }
71922
71923
71924 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_ChildProperty() {
71925   void * jresult ;
71926   Dali::Toolkit::FlexContainer::ChildProperty *result = 0 ;
71927
71928   {
71929     try {
71930       result = (Dali::Toolkit::FlexContainer::ChildProperty *)new Dali::Toolkit::FlexContainer::ChildProperty();
71931     } catch (std::out_of_range& e) {
71932       {
71933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71934       };
71935     } catch (std::exception& e) {
71936       {
71937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71938       };
71939     } catch (Dali::DaliException e) {
71940       {
71941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71942       };
71943     } catch (...) {
71944       {
71945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71946       };
71947     }
71948   }
71949
71950   jresult = (void *)result;
71951   return jresult;
71952 }
71953
71954
71955 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_ChildProperty(void * jarg1) {
71956   Dali::Toolkit::FlexContainer::ChildProperty *arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *) 0 ;
71957
71958   arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *)jarg1;
71959   {
71960     try {
71961       delete arg1;
71962     } catch (std::out_of_range& e) {
71963       {
71964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71965       };
71966     } catch (std::exception& e) {
71967       {
71968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71969       };
71970     } catch (Dali::DaliException e) {
71971       {
71972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71973       };
71974     } catch (...) {
71975       {
71976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71977       };
71978     }
71979   }
71980
71981 }
71982
71983
71984 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_0() {
71985   void * jresult ;
71986   Dali::Toolkit::FlexContainer *result = 0 ;
71987
71988   {
71989     try {
71990       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer();
71991     } catch (std::out_of_range& e) {
71992       {
71993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71994       };
71995     } catch (std::exception& e) {
71996       {
71997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71998       };
71999     } catch (Dali::DaliException e) {
72000       {
72001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72002       };
72003     } catch (...) {
72004       {
72005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72006       };
72007     }
72008   }
72009
72010   jresult = (void *)result;
72011   return jresult;
72012 }
72013
72014
72015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_1(void * jarg1) {
72016   void * jresult ;
72017   Dali::Toolkit::FlexContainer *arg1 = 0 ;
72018   Dali::Toolkit::FlexContainer *result = 0 ;
72019
72020   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
72021   if (!arg1) {
72022     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
72023     return 0;
72024   }
72025   {
72026     try {
72027       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer((Dali::Toolkit::FlexContainer const &)*arg1);
72028     } catch (std::out_of_range& e) {
72029       {
72030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72031       };
72032     } catch (std::exception& e) {
72033       {
72034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72035       };
72036     } catch (Dali::DaliException e) {
72037       {
72038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72039       };
72040     } catch (...) {
72041       {
72042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72043       };
72044     }
72045   }
72046
72047   jresult = (void *)result;
72048   return jresult;
72049 }
72050
72051
72052 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_Assign(void * jarg1, void * jarg2) {
72053   void * jresult ;
72054   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
72055   Dali::Toolkit::FlexContainer *arg2 = 0 ;
72056   Dali::Toolkit::FlexContainer *result = 0 ;
72057
72058   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
72059   arg2 = (Dali::Toolkit::FlexContainer *)jarg2;
72060   if (!arg2) {
72061     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
72062     return 0;
72063   }
72064   {
72065     try {
72066       result = (Dali::Toolkit::FlexContainer *) &(arg1)->operator =((Dali::Toolkit::FlexContainer const &)*arg2);
72067     } catch (std::out_of_range& e) {
72068       {
72069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72070       };
72071     } catch (std::exception& e) {
72072       {
72073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72074       };
72075     } catch (Dali::DaliException e) {
72076       {
72077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72078       };
72079     } catch (...) {
72080       {
72081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72082       };
72083     }
72084   }
72085
72086   jresult = (void *)result;
72087   return jresult;
72088 }
72089
72090
72091 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer(void * jarg1) {
72092   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
72093
72094   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
72095   {
72096     try {
72097       delete arg1;
72098     } catch (std::out_of_range& e) {
72099       {
72100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72101       };
72102     } catch (std::exception& e) {
72103       {
72104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72105       };
72106     } catch (Dali::DaliException e) {
72107       {
72108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72109       };
72110     } catch (...) {
72111       {
72112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72113       };
72114     }
72115   }
72116
72117 }
72118
72119
72120 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_New() {
72121   void * jresult ;
72122   Dali::Toolkit::FlexContainer result;
72123
72124   {
72125     try {
72126       result = Dali::Toolkit::FlexContainer::New();
72127     } catch (std::out_of_range& e) {
72128       {
72129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72130       };
72131     } catch (std::exception& e) {
72132       {
72133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72134       };
72135     } catch (Dali::DaliException e) {
72136       {
72137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72138       };
72139     } catch (...) {
72140       {
72141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72142       };
72143     }
72144   }
72145
72146   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
72147   return jresult;
72148 }
72149
72150
72151 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_DownCast(void * jarg1) {
72152   void * jresult ;
72153   Dali::BaseHandle arg1 ;
72154   Dali::BaseHandle *argp1 ;
72155   Dali::Toolkit::FlexContainer result;
72156
72157   argp1 = (Dali::BaseHandle *)jarg1;
72158   if (!argp1) {
72159     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
72160     return 0;
72161   }
72162   arg1 = *argp1;
72163   {
72164     try {
72165       result = Dali::Toolkit::FlexContainer::DownCast(arg1);
72166     } catch (std::out_of_range& e) {
72167       {
72168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72169       };
72170     } catch (std::exception& e) {
72171       {
72172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72173       };
72174     } catch (Dali::DaliException e) {
72175       {
72176         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72177       };
72178     } catch (...) {
72179       {
72180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72181       };
72182     }
72183   }
72184
72185   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
72186   return jresult;
72187 }
72188
72189
72190 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_RESOURCE_URL_get() {
72191   int jresult ;
72192   int result;
72193
72194   result = (int)Dali::Toolkit::ImageView::Property::RESOURCE_URL;
72195   jresult = (int)result;
72196   return jresult;
72197 }
72198
72199
72200 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_IMAGE_get() {
72201   int jresult ;
72202   int result;
72203
72204   result = (int)Dali::Toolkit::ImageView::Property::IMAGE;
72205   jresult = (int)result;
72206   return jresult;
72207 }
72208
72209
72210 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PRE_MULTIPLIED_ALPHA_get() {
72211   int jresult ;
72212   int result;
72213
72214   result = (int)Dali::Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA;
72215   jresult = (int)result;
72216   return jresult;
72217 }
72218
72219
72220 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PIXEL_AREA_get() {
72221   int jresult ;
72222   int result;
72223
72224   result = (int)Dali::Toolkit::ImageView::Property::PIXEL_AREA;
72225   jresult = (int)result;
72226   return jresult;
72227 }
72228
72229
72230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView_Property() {
72231   void * jresult ;
72232   Dali::Toolkit::ImageView::Property *result = 0 ;
72233
72234   {
72235     try {
72236       result = (Dali::Toolkit::ImageView::Property *)new Dali::Toolkit::ImageView::Property();
72237     } catch (std::out_of_range& e) {
72238       {
72239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72240       };
72241     } catch (std::exception& e) {
72242       {
72243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72244       };
72245     } catch (Dali::DaliException e) {
72246       {
72247         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72248       };
72249     } catch (...) {
72250       {
72251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72252       };
72253     }
72254   }
72255
72256   jresult = (void *)result;
72257   return jresult;
72258 }
72259
72260
72261 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView_Property(void * jarg1) {
72262   Dali::Toolkit::ImageView::Property *arg1 = (Dali::Toolkit::ImageView::Property *) 0 ;
72263
72264   arg1 = (Dali::Toolkit::ImageView::Property *)jarg1;
72265   {
72266     try {
72267       delete arg1;
72268     } catch (std::out_of_range& e) {
72269       {
72270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72271       };
72272     } catch (std::exception& e) {
72273       {
72274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72275       };
72276     } catch (Dali::DaliException e) {
72277       {
72278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72279       };
72280     } catch (...) {
72281       {
72282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72283       };
72284     }
72285   }
72286
72287 }
72288
72289
72290 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_0() {
72291   void * jresult ;
72292   Dali::Toolkit::ImageView *result = 0 ;
72293
72294   {
72295     try {
72296       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView();
72297     } catch (std::out_of_range& e) {
72298       {
72299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72300       };
72301     } catch (std::exception& e) {
72302       {
72303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72304       };
72305     } catch (Dali::DaliException e) {
72306       {
72307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72308       };
72309     } catch (...) {
72310       {
72311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72312       };
72313     }
72314   }
72315
72316   jresult = (void *)result;
72317   return jresult;
72318 }
72319
72320
72321 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_0() {
72322   void * jresult ;
72323   Dali::Toolkit::ImageView result;
72324
72325   {
72326     try {
72327       result = Dali::Toolkit::ImageView::New();
72328     } catch (std::out_of_range& e) {
72329       {
72330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72331       };
72332     } catch (std::exception& e) {
72333       {
72334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72335       };
72336     } catch (Dali::DaliException e) {
72337       {
72338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72339       };
72340     } catch (...) {
72341       {
72342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72343       };
72344     }
72345   }
72346
72347   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
72348   return jresult;
72349 }
72350
72351
72352 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_1(void * jarg1) {
72353   void * jresult ;
72354   Dali::Image arg1 ;
72355   Dali::Image *argp1 ;
72356   Dali::Toolkit::ImageView result;
72357
72358   argp1 = (Dali::Image *)jarg1;
72359   if (!argp1) {
72360     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
72361     return 0;
72362   }
72363   arg1 = *argp1;
72364   {
72365     try {
72366       result = Dali::Toolkit::ImageView::New(arg1);
72367     } catch (std::out_of_range& e) {
72368       {
72369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72370       };
72371     } catch (std::exception& e) {
72372       {
72373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72374       };
72375     } catch (Dali::DaliException e) {
72376       {
72377         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72378       };
72379     } catch (...) {
72380       {
72381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72382       };
72383     }
72384   }
72385
72386   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
72387   return jresult;
72388 }
72389
72390
72391 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_2(char * jarg1) {
72392   void * jresult ;
72393   std::string *arg1 = 0 ;
72394   Dali::Toolkit::ImageView result;
72395
72396   if (!jarg1) {
72397     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72398     return 0;
72399   }
72400   std::string arg1_str(jarg1);
72401   arg1 = &arg1_str;
72402   {
72403     try {
72404       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1);
72405     } catch (std::out_of_range& e) {
72406       {
72407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72408       };
72409     } catch (std::exception& e) {
72410       {
72411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72412       };
72413     } catch (Dali::DaliException e) {
72414       {
72415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72416       };
72417     } catch (...) {
72418       {
72419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72420       };
72421     }
72422   }
72423
72424   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
72425
72426   //argout typemap for const std::string&
72427
72428   return jresult;
72429 }
72430
72431
72432 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_3(char * jarg1, void * jarg2) {
72433   void * jresult ;
72434   std::string *arg1 = 0 ;
72435   Dali::ImageDimensions arg2 ;
72436   Dali::ImageDimensions *argp2 ;
72437   Dali::Toolkit::ImageView result;
72438
72439   if (!jarg1) {
72440     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72441     return 0;
72442   }
72443   std::string arg1_str(jarg1);
72444   arg1 = &arg1_str;
72445   argp2 = (Dali::ImageDimensions *)jarg2;
72446   if (!argp2) {
72447     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
72448     return 0;
72449   }
72450   arg2 = *argp2;
72451   {
72452     try {
72453       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1,arg2);
72454     } catch (std::out_of_range& e) {
72455       {
72456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72457       };
72458     } catch (std::exception& e) {
72459       {
72460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72461       };
72462     } catch (Dali::DaliException e) {
72463       {
72464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72465       };
72466     } catch (...) {
72467       {
72468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72469       };
72470     }
72471   }
72472
72473   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
72474
72475   //argout typemap for const std::string&
72476
72477   return jresult;
72478 }
72479
72480
72481 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView(void * jarg1) {
72482   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72483
72484   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72485   {
72486     try {
72487       delete arg1;
72488     } catch (std::out_of_range& e) {
72489       {
72490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72491       };
72492     } catch (std::exception& e) {
72493       {
72494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72495       };
72496     } catch (Dali::DaliException e) {
72497       {
72498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72499       };
72500     } catch (...) {
72501       {
72502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72503       };
72504     }
72505   }
72506
72507 }
72508
72509
72510 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_1(void * jarg1) {
72511   void * jresult ;
72512   Dali::Toolkit::ImageView *arg1 = 0 ;
72513   Dali::Toolkit::ImageView *result = 0 ;
72514
72515   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72516   if (!arg1) {
72517     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
72518     return 0;
72519   }
72520   {
72521     try {
72522       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView((Dali::Toolkit::ImageView const &)*arg1);
72523     } catch (std::out_of_range& e) {
72524       {
72525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72526       };
72527     } catch (std::exception& e) {
72528       {
72529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72530       };
72531     } catch (Dali::DaliException e) {
72532       {
72533         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72534       };
72535     } catch (...) {
72536       {
72537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72538       };
72539     }
72540   }
72541
72542   jresult = (void *)result;
72543   return jresult;
72544 }
72545
72546
72547 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_Assign(void * jarg1, void * jarg2) {
72548   void * jresult ;
72549   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72550   Dali::Toolkit::ImageView *arg2 = 0 ;
72551   Dali::Toolkit::ImageView *result = 0 ;
72552
72553   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72554   arg2 = (Dali::Toolkit::ImageView *)jarg2;
72555   if (!arg2) {
72556     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
72557     return 0;
72558   }
72559   {
72560     try {
72561       result = (Dali::Toolkit::ImageView *) &(arg1)->operator =((Dali::Toolkit::ImageView const &)*arg2);
72562     } catch (std::out_of_range& e) {
72563       {
72564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72565       };
72566     } catch (std::exception& e) {
72567       {
72568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72569       };
72570     } catch (Dali::DaliException e) {
72571       {
72572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72573       };
72574     } catch (...) {
72575       {
72576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72577       };
72578     }
72579   }
72580
72581   jresult = (void *)result;
72582   return jresult;
72583 }
72584
72585
72586 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_DownCast(void * jarg1) {
72587   void * jresult ;
72588   Dali::BaseHandle arg1 ;
72589   Dali::BaseHandle *argp1 ;
72590   Dali::Toolkit::ImageView result;
72591
72592   argp1 = (Dali::BaseHandle *)jarg1;
72593   if (!argp1) {
72594     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
72595     return 0;
72596   }
72597   arg1 = *argp1;
72598   {
72599     try {
72600       result = Dali::Toolkit::ImageView::DownCast(arg1);
72601     } catch (std::out_of_range& e) {
72602       {
72603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72604       };
72605     } catch (std::exception& e) {
72606       {
72607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72608       };
72609     } catch (Dali::DaliException e) {
72610       {
72611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72612       };
72613     } catch (...) {
72614       {
72615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72616       };
72617     }
72618   }
72619
72620   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
72621   return jresult;
72622 }
72623
72624
72625 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_0(void * jarg1, void * jarg2) {
72626   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72627   Dali::Image arg2 ;
72628   Dali::Image *argp2 ;
72629
72630   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72631   argp2 = (Dali::Image *)jarg2;
72632   if (!argp2) {
72633     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
72634     return ;
72635   }
72636   arg2 = *argp2;
72637   {
72638     try {
72639       (arg1)->SetImage(arg2);
72640     } catch (std::out_of_range& e) {
72641       {
72642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72643       };
72644     } catch (std::exception& e) {
72645       {
72646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72647       };
72648     } catch (Dali::DaliException e) {
72649       {
72650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72651       };
72652     } catch (...) {
72653       {
72654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72655       };
72656     }
72657   }
72658
72659 }
72660
72661
72662 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_1(void * jarg1, char * jarg2) {
72663   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72664   std::string *arg2 = 0 ;
72665
72666   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72667   if (!jarg2) {
72668     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72669     return ;
72670   }
72671   std::string arg2_str(jarg2);
72672   arg2 = &arg2_str;
72673   {
72674     try {
72675       (arg1)->SetImage((std::string const &)*arg2);
72676     } catch (std::out_of_range& e) {
72677       {
72678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72679       };
72680     } catch (std::exception& e) {
72681       {
72682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72683       };
72684     } catch (Dali::DaliException e) {
72685       {
72686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72687       };
72688     } catch (...) {
72689       {
72690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72691       };
72692     }
72693   }
72694
72695
72696   //argout typemap for const std::string&
72697
72698 }
72699
72700
72701 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
72702   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72703   std::string *arg2 = 0 ;
72704   Dali::ImageDimensions arg3 ;
72705   Dali::ImageDimensions *argp3 ;
72706
72707   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72708   if (!jarg2) {
72709     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72710     return ;
72711   }
72712   std::string arg2_str(jarg2);
72713   arg2 = &arg2_str;
72714   argp3 = (Dali::ImageDimensions *)jarg3;
72715   if (!argp3) {
72716     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
72717     return ;
72718   }
72719   arg3 = *argp3;
72720   {
72721     try {
72722       (arg1)->SetImage((std::string const &)*arg2,arg3);
72723     } catch (std::out_of_range& e) {
72724       {
72725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72726       };
72727     } catch (std::exception& e) {
72728       {
72729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72730       };
72731     } catch (Dali::DaliException e) {
72732       {
72733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72734       };
72735     } catch (...) {
72736       {
72737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72738       };
72739     }
72740   }
72741
72742
72743   //argout typemap for const std::string&
72744
72745 }
72746
72747 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_GetImage(void * jarg1) {
72748   void * jresult ;
72749   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72750   Dali::Image result;
72751
72752   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72753   {
72754     try {
72755       result = ((Dali::Toolkit::ImageView const *)arg1)->GetImage();
72756     } catch (std::out_of_range& e) {
72757       {
72758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72759       };
72760     } catch (std::exception& e) {
72761       {
72762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72763       };
72764     } catch (Dali::DaliException e) {
72765       {
72766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72767       };
72768     } catch (...) {
72769       {
72770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72771       };
72772     }
72773   }
72774
72775   jresult = new Dali::Image((const Dali::Image &)result);
72776   return jresult;
72777 }
72778
72779
72780 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_GEOMETRY_URL_get() {
72781   int jresult ;
72782   int result;
72783
72784   result = (int)Dali::Toolkit::Model3dView::Property::GEOMETRY_URL;
72785   jresult = (int)result;
72786   return jresult;
72787 }
72788
72789
72790 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_MATERIAL_URL_get() {
72791   int jresult ;
72792   int result;
72793
72794   result = (int)Dali::Toolkit::Model3dView::Property::MATERIAL_URL;
72795   jresult = (int)result;
72796   return jresult;
72797 }
72798
72799
72800 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_IMAGES_URL_get() {
72801   int jresult ;
72802   int result;
72803
72804   result = (int)Dali::Toolkit::Model3dView::Property::IMAGES_URL;
72805   jresult = (int)result;
72806   return jresult;
72807 }
72808
72809
72810 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_ILLUMINATION_TYPE_get() {
72811   int jresult ;
72812   int result;
72813
72814   result = (int)Dali::Toolkit::Model3dView::Property::ILLUMINATION_TYPE;
72815   jresult = (int)result;
72816   return jresult;
72817 }
72818
72819
72820 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE0_URL_get() {
72821   int jresult ;
72822   int result;
72823
72824   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE0_URL;
72825   jresult = (int)result;
72826   return jresult;
72827 }
72828
72829
72830 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE1_URL_get() {
72831   int jresult ;
72832   int result;
72833
72834   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE1_URL;
72835   jresult = (int)result;
72836   return jresult;
72837 }
72838
72839
72840 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE2_URL_get() {
72841   int jresult ;
72842   int result;
72843
72844   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE2_URL;
72845   jresult = (int)result;
72846   return jresult;
72847 }
72848
72849
72850 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_LIGHT_POSITION_get() {
72851   int jresult ;
72852   int result;
72853
72854   result = (int)Dali::Toolkit::Model3dView::Property::LIGHT_POSITION;
72855   jresult = (int)result;
72856   return jresult;
72857 }
72858
72859
72860 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView_Property() {
72861   void * jresult ;
72862   Dali::Toolkit::Model3dView::Property *result = 0 ;
72863
72864   {
72865     try {
72866       result = (Dali::Toolkit::Model3dView::Property *)new Dali::Toolkit::Model3dView::Property();
72867     } catch (std::out_of_range& e) {
72868       {
72869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72870       };
72871     } catch (std::exception& e) {
72872       {
72873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72874       };
72875     } catch (Dali::DaliException e) {
72876       {
72877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72878       };
72879     } catch (...) {
72880       {
72881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72882       };
72883     }
72884   }
72885
72886   jresult = (void *)result;
72887   return jresult;
72888 }
72889
72890
72891 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView_Property(void * jarg1) {
72892   Dali::Toolkit::Model3dView::Property *arg1 = (Dali::Toolkit::Model3dView::Property *) 0 ;
72893
72894   arg1 = (Dali::Toolkit::Model3dView::Property *)jarg1;
72895   {
72896     try {
72897       delete arg1;
72898     } catch (std::out_of_range& e) {
72899       {
72900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72901       };
72902     } catch (std::exception& e) {
72903       {
72904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72905       };
72906     } catch (Dali::DaliException e) {
72907       {
72908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72909       };
72910     } catch (...) {
72911       {
72912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72913       };
72914     }
72915   }
72916
72917 }
72918
72919
72920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_0() {
72921   void * jresult ;
72922   Dali::Toolkit::Model3dView result;
72923
72924   {
72925     try {
72926       result = Dali::Toolkit::Model3dView::New();
72927     } catch (std::out_of_range& e) {
72928       {
72929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72930       };
72931     } catch (std::exception& e) {
72932       {
72933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72934       };
72935     } catch (Dali::DaliException e) {
72936       {
72937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72938       };
72939     } catch (...) {
72940       {
72941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72942       };
72943     }
72944   }
72945
72946   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
72947   return jresult;
72948 }
72949
72950
72951 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_1(char * jarg1, char * jarg2, char * jarg3) {
72952   void * jresult ;
72953   std::string *arg1 = 0 ;
72954   std::string *arg2 = 0 ;
72955   std::string *arg3 = 0 ;
72956   Dali::Toolkit::Model3dView result;
72957
72958   if (!jarg1) {
72959     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72960     return 0;
72961   }
72962   std::string arg1_str(jarg1);
72963   arg1 = &arg1_str;
72964   if (!jarg2) {
72965     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72966     return 0;
72967   }
72968   std::string arg2_str(jarg2);
72969   arg2 = &arg2_str;
72970   if (!jarg3) {
72971     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72972     return 0;
72973   }
72974   std::string arg3_str(jarg3);
72975   arg3 = &arg3_str;
72976   {
72977     try {
72978       result = Dali::Toolkit::Model3dView::New((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3);
72979     } catch (std::out_of_range& e) {
72980       {
72981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72982       };
72983     } catch (std::exception& e) {
72984       {
72985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72986       };
72987     } catch (Dali::DaliException e) {
72988       {
72989         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72990       };
72991     } catch (...) {
72992       {
72993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72994       };
72995     }
72996   }
72997
72998   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
72999
73000   //argout typemap for const std::string&
73001
73002
73003   //argout typemap for const std::string&
73004
73005
73006   //argout typemap for const std::string&
73007
73008   return jresult;
73009 }
73010
73011
73012 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_0() {
73013   void * jresult ;
73014   Dali::Toolkit::Model3dView *result = 0 ;
73015
73016   {
73017     try {
73018       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView();
73019     } catch (std::out_of_range& e) {
73020       {
73021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73022       };
73023     } catch (std::exception& e) {
73024       {
73025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73026       };
73027     } catch (Dali::DaliException e) {
73028       {
73029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73030       };
73031     } catch (...) {
73032       {
73033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73034       };
73035     }
73036   }
73037
73038   jresult = (void *)result;
73039   return jresult;
73040 }
73041
73042
73043 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView(void * jarg1) {
73044   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
73045
73046   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
73047   {
73048     try {
73049       delete arg1;
73050     } catch (std::out_of_range& e) {
73051       {
73052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73053       };
73054     } catch (std::exception& e) {
73055       {
73056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73057       };
73058     } catch (Dali::DaliException e) {
73059       {
73060         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73061       };
73062     } catch (...) {
73063       {
73064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73065       };
73066     }
73067   }
73068
73069 }
73070
73071
73072 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_1(void * jarg1) {
73073   void * jresult ;
73074   Dali::Toolkit::Model3dView *arg1 = 0 ;
73075   Dali::Toolkit::Model3dView *result = 0 ;
73076
73077   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
73078   if (!arg1) {
73079     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
73080     return 0;
73081   }
73082   {
73083     try {
73084       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView((Dali::Toolkit::Model3dView const &)*arg1);
73085     } catch (std::out_of_range& e) {
73086       {
73087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73088       };
73089     } catch (std::exception& e) {
73090       {
73091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73092       };
73093     } catch (Dali::DaliException e) {
73094       {
73095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73096       };
73097     } catch (...) {
73098       {
73099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73100       };
73101     }
73102   }
73103
73104   jresult = (void *)result;
73105   return jresult;
73106 }
73107
73108
73109 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_Assign(void * jarg1, void * jarg2) {
73110   void * jresult ;
73111   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
73112   Dali::Toolkit::Model3dView *arg2 = 0 ;
73113   Dali::Toolkit::Model3dView *result = 0 ;
73114
73115   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
73116   arg2 = (Dali::Toolkit::Model3dView *)jarg2;
73117   if (!arg2) {
73118     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
73119     return 0;
73120   }
73121   {
73122     try {
73123       result = (Dali::Toolkit::Model3dView *) &(arg1)->operator =((Dali::Toolkit::Model3dView const &)*arg2);
73124     } catch (std::out_of_range& e) {
73125       {
73126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73127       };
73128     } catch (std::exception& e) {
73129       {
73130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73131       };
73132     } catch (Dali::DaliException e) {
73133       {
73134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73135       };
73136     } catch (...) {
73137       {
73138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73139       };
73140     }
73141   }
73142
73143   jresult = (void *)result;
73144   return jresult;
73145 }
73146
73147
73148 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_DownCast(void * jarg1) {
73149   void * jresult ;
73150   Dali::BaseHandle arg1 ;
73151   Dali::BaseHandle *argp1 ;
73152   Dali::Toolkit::Model3dView result;
73153
73154   argp1 = (Dali::BaseHandle *)jarg1;
73155   if (!argp1) {
73156     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
73157     return 0;
73158   }
73159   arg1 = *argp1;
73160   {
73161     try {
73162       result = Dali::Toolkit::Model3dView::DownCast(arg1);
73163     } catch (std::out_of_range& e) {
73164       {
73165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73166       };
73167     } catch (std::exception& e) {
73168       {
73169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73170       };
73171     } catch (Dali::DaliException e) {
73172       {
73173         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73174       };
73175     } catch (...) {
73176       {
73177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73178       };
73179     }
73180   }
73181
73182   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
73183   return jresult;
73184 }
73185
73186
73187 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_DIRECTION_get() {
73188   int jresult ;
73189   int result;
73190
73191   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_DIRECTION;
73192   jresult = (int)result;
73193   return jresult;
73194 }
73195
73196
73197 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HEIGHT_POLICY_get() {
73198   int jresult ;
73199   int result;
73200
73201   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HEIGHT_POLICY;
73202   jresult = (int)result;
73203   return jresult;
73204 }
73205
73206
73207 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_FIXED_HEIGHT_get() {
73208   int jresult ;
73209   int result;
73210
73211   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_FIXED_HEIGHT;
73212   jresult = (int)result;
73213   return jresult;
73214 }
73215
73216
73217 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_SHOW_DURATION_get() {
73218   int jresult ;
73219   int result;
73220
73221   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_SHOW_DURATION;
73222   jresult = (int)result;
73223   return jresult;
73224 }
73225
73226
73227 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HIDE_DURATION_get() {
73228   int jresult ;
73229   int result;
73230
73231   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HIDE_DURATION;
73232   jresult = (int)result;
73233   return jresult;
73234 }
73235
73236
73237 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_POSITION_INTERVALS_get() {
73238   int jresult ;
73239   int result;
73240
73241   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_POSITION_INTERVALS;
73242   jresult = (int)result;
73243   return jresult;
73244 }
73245
73246
73247 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_MINIMUM_HEIGHT_get() {
73248   int jresult ;
73249   int result;
73250
73251   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_MINIMUM_HEIGHT;
73252   jresult = (int)result;
73253   return jresult;
73254 }
73255
73256
73257 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_START_PADDING_get() {
73258   int jresult ;
73259   int result;
73260
73261   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_START_PADDING;
73262   jresult = (int)result;
73263   return jresult;
73264 }
73265
73266
73267 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_END_PADDING_get() {
73268   int jresult ;
73269   int result;
73270
73271   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_END_PADDING;
73272   jresult = (int)result;
73273   return jresult;
73274 }
73275
73276
73277 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar_Property() {
73278   void * jresult ;
73279   Dali::Toolkit::ScrollBar::Property *result = 0 ;
73280
73281   {
73282     try {
73283       result = (Dali::Toolkit::ScrollBar::Property *)new Dali::Toolkit::ScrollBar::Property();
73284     } catch (std::out_of_range& e) {
73285       {
73286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73287       };
73288     } catch (std::exception& e) {
73289       {
73290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73291       };
73292     } catch (Dali::DaliException e) {
73293       {
73294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73295       };
73296     } catch (...) {
73297       {
73298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73299       };
73300     }
73301   }
73302
73303   jresult = (void *)result;
73304   return jresult;
73305 }
73306
73307
73308 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar_Property(void * jarg1) {
73309   Dali::Toolkit::ScrollBar::Property *arg1 = (Dali::Toolkit::ScrollBar::Property *) 0 ;
73310
73311   arg1 = (Dali::Toolkit::ScrollBar::Property *)jarg1;
73312   {
73313     try {
73314       delete arg1;
73315     } catch (std::out_of_range& e) {
73316       {
73317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73318       };
73319     } catch (std::exception& e) {
73320       {
73321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73322       };
73323     } catch (Dali::DaliException e) {
73324       {
73325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73326       };
73327     } catch (...) {
73328       {
73329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73330       };
73331     }
73332   }
73333
73334 }
73335
73336
73337 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_0() {
73338   void * jresult ;
73339   Dali::Toolkit::ScrollBar *result = 0 ;
73340
73341   {
73342     try {
73343       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar();
73344     } catch (std::out_of_range& e) {
73345       {
73346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73347       };
73348     } catch (std::exception& e) {
73349       {
73350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73351       };
73352     } catch (Dali::DaliException e) {
73353       {
73354         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73355       };
73356     } catch (...) {
73357       {
73358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73359       };
73360     }
73361   }
73362
73363   jresult = (void *)result;
73364   return jresult;
73365 }
73366
73367
73368 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_1(void * jarg1) {
73369   void * jresult ;
73370   Dali::Toolkit::ScrollBar *arg1 = 0 ;
73371   Dali::Toolkit::ScrollBar *result = 0 ;
73372
73373   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73374   if (!arg1) {
73375     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
73376     return 0;
73377   }
73378   {
73379     try {
73380       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar((Dali::Toolkit::ScrollBar const &)*arg1);
73381     } catch (std::out_of_range& e) {
73382       {
73383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73384       };
73385     } catch (std::exception& e) {
73386       {
73387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73388       };
73389     } catch (Dali::DaliException e) {
73390       {
73391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73392       };
73393     } catch (...) {
73394       {
73395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73396       };
73397     }
73398   }
73399
73400   jresult = (void *)result;
73401   return jresult;
73402 }
73403
73404
73405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_Assign(void * jarg1, void * jarg2) {
73406   void * jresult ;
73407   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73408   Dali::Toolkit::ScrollBar *arg2 = 0 ;
73409   Dali::Toolkit::ScrollBar *result = 0 ;
73410
73411   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73412   arg2 = (Dali::Toolkit::ScrollBar *)jarg2;
73413   if (!arg2) {
73414     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
73415     return 0;
73416   }
73417   {
73418     try {
73419       result = (Dali::Toolkit::ScrollBar *) &(arg1)->operator =((Dali::Toolkit::ScrollBar const &)*arg2);
73420     } catch (std::out_of_range& e) {
73421       {
73422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73423       };
73424     } catch (std::exception& e) {
73425       {
73426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73427       };
73428     } catch (Dali::DaliException e) {
73429       {
73430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73431       };
73432     } catch (...) {
73433       {
73434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73435       };
73436     }
73437   }
73438
73439   jresult = (void *)result;
73440   return jresult;
73441 }
73442
73443
73444 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar(void * jarg1) {
73445   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73446
73447   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73448   {
73449     try {
73450       delete arg1;
73451     } catch (std::out_of_range& e) {
73452       {
73453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73454       };
73455     } catch (std::exception& e) {
73456       {
73457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73458       };
73459     } catch (Dali::DaliException e) {
73460       {
73461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73462       };
73463     } catch (...) {
73464       {
73465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73466       };
73467     }
73468   }
73469
73470 }
73471
73472
73473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_0(int jarg1) {
73474   void * jresult ;
73475   Dali::Toolkit::ScrollBar::Direction arg1 ;
73476   Dali::Toolkit::ScrollBar result;
73477
73478   arg1 = (Dali::Toolkit::ScrollBar::Direction)jarg1;
73479   {
73480     try {
73481       result = Dali::Toolkit::ScrollBar::New(arg1);
73482     } catch (std::out_of_range& e) {
73483       {
73484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73485       };
73486     } catch (std::exception& e) {
73487       {
73488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73489       };
73490     } catch (Dali::DaliException e) {
73491       {
73492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73493       };
73494     } catch (...) {
73495       {
73496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73497       };
73498     }
73499   }
73500
73501   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
73502   return jresult;
73503 }
73504
73505
73506 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_1() {
73507   void * jresult ;
73508   Dali::Toolkit::ScrollBar result;
73509
73510   {
73511     try {
73512       result = Dali::Toolkit::ScrollBar::New();
73513     } catch (std::out_of_range& e) {
73514       {
73515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73516       };
73517     } catch (std::exception& e) {
73518       {
73519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73520       };
73521     } catch (Dali::DaliException e) {
73522       {
73523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73524       };
73525     } catch (...) {
73526       {
73527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73528       };
73529     }
73530   }
73531
73532   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
73533   return jresult;
73534 }
73535
73536
73537 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_DownCast(void * jarg1) {
73538   void * jresult ;
73539   Dali::BaseHandle arg1 ;
73540   Dali::BaseHandle *argp1 ;
73541   Dali::Toolkit::ScrollBar result;
73542
73543   argp1 = (Dali::BaseHandle *)jarg1;
73544   if (!argp1) {
73545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
73546     return 0;
73547   }
73548   arg1 = *argp1;
73549   {
73550     try {
73551       result = Dali::Toolkit::ScrollBar::DownCast(arg1);
73552     } catch (std::out_of_range& e) {
73553       {
73554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73555       };
73556     } catch (std::exception& e) {
73557       {
73558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73559       };
73560     } catch (Dali::DaliException e) {
73561       {
73562         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73563       };
73564     } catch (...) {
73565       {
73566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73567       };
73568     }
73569   }
73570
73571   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
73572   return jresult;
73573 }
73574
73575
73576 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPropertySource(void * jarg1, void * jarg2, int jarg3, int jarg4, int jarg5, int jarg6) {
73577   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73578   Dali::Handle arg2 ;
73579   Dali::Property::Index arg3 ;
73580   Dali::Property::Index arg4 ;
73581   Dali::Property::Index arg5 ;
73582   Dali::Property::Index arg6 ;
73583   Dali::Handle *argp2 ;
73584
73585   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73586   argp2 = (Dali::Handle *)jarg2;
73587   if (!argp2) {
73588     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Handle", 0);
73589     return ;
73590   }
73591   arg2 = *argp2;
73592   arg3 = (Dali::Property::Index)jarg3;
73593   arg4 = (Dali::Property::Index)jarg4;
73594   arg5 = (Dali::Property::Index)jarg5;
73595   arg6 = (Dali::Property::Index)jarg6;
73596   {
73597     try {
73598       (arg1)->SetScrollPropertySource(arg2,arg3,arg4,arg5,arg6);
73599     } catch (std::out_of_range& e) {
73600       {
73601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73602       };
73603     } catch (std::exception& e) {
73604       {
73605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73606       };
73607     } catch (Dali::DaliException e) {
73608       {
73609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73610       };
73611     } catch (...) {
73612       {
73613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73614       };
73615     }
73616   }
73617
73618 }
73619
73620
73621 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollIndicator(void * jarg1, void * jarg2) {
73622   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73623   Dali::Actor arg2 ;
73624   Dali::Actor *argp2 ;
73625
73626   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73627   argp2 = (Dali::Actor *)jarg2;
73628   if (!argp2) {
73629     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
73630     return ;
73631   }
73632   arg2 = *argp2;
73633   {
73634     try {
73635       (arg1)->SetScrollIndicator(arg2);
73636     } catch (std::out_of_range& e) {
73637       {
73638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73639       };
73640     } catch (std::exception& e) {
73641       {
73642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73643       };
73644     } catch (Dali::DaliException e) {
73645       {
73646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73647       };
73648     } catch (...) {
73649       {
73650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73651       };
73652     }
73653   }
73654
73655 }
73656
73657
73658 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollIndicator(void * jarg1) {
73659   void * jresult ;
73660   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73661   Dali::Actor result;
73662
73663   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73664   {
73665     try {
73666       result = (arg1)->GetScrollIndicator();
73667     } catch (std::out_of_range& e) {
73668       {
73669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73670       };
73671     } catch (std::exception& e) {
73672       {
73673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73674       };
73675     } catch (Dali::DaliException e) {
73676       {
73677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73678       };
73679     } catch (...) {
73680       {
73681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73682       };
73683     }
73684   }
73685
73686   jresult = new Dali::Actor((const Dali::Actor &)result);
73687   return jresult;
73688 }
73689
73690
73691 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPositionIntervals(void * jarg1, void * jarg2) {
73692   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73693   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg2 = 0 ;
73694
73695   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73696   arg2 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg2;
73697   if (!arg2) {
73698     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
73699     return ;
73700   }
73701   {
73702     try {
73703       (arg1)->SetScrollPositionIntervals((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg2);
73704     } catch (std::out_of_range& e) {
73705       {
73706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73707       };
73708     } catch (std::exception& e) {
73709       {
73710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73711       };
73712     } catch (Dali::DaliException e) {
73713       {
73714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73715       };
73716     } catch (...) {
73717       {
73718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73719       };
73720     }
73721   }
73722
73723 }
73724
73725
73726 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollPositionIntervals(void * jarg1) {
73727   void * jresult ;
73728   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73729
73730   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73731   {
73732     try {
73733       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()));
73734     } catch (std::out_of_range& e) {
73735       {
73736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73737       };
73738     } catch (std::exception& e) {
73739       {
73740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73741       };
73742     } catch (...) {
73743       {
73744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73745       };
73746     }
73747   }
73748   return jresult;
73749 }
73750
73751
73752 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollDirection(void * jarg1, int jarg2) {
73753   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73754   Dali::Toolkit::ScrollBar::Direction arg2 ;
73755
73756   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73757   arg2 = (Dali::Toolkit::ScrollBar::Direction)jarg2;
73758   {
73759     try {
73760       (arg1)->SetScrollDirection(arg2);
73761     } catch (std::out_of_range& e) {
73762       {
73763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73764       };
73765     } catch (std::exception& e) {
73766       {
73767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73768       };
73769     } catch (Dali::DaliException e) {
73770       {
73771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73772       };
73773     } catch (...) {
73774       {
73775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73776       };
73777     }
73778   }
73779
73780 }
73781
73782
73783 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollDirection(void * jarg1) {
73784   int jresult ;
73785   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73786   Dali::Toolkit::ScrollBar::Direction result;
73787
73788   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73789   {
73790     try {
73791       result = (Dali::Toolkit::ScrollBar::Direction)((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollDirection();
73792     } catch (std::out_of_range& e) {
73793       {
73794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73795       };
73796     } catch (std::exception& e) {
73797       {
73798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73799       };
73800     } catch (Dali::DaliException e) {
73801       {
73802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73803       };
73804     } catch (...) {
73805       {
73806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73807       };
73808     }
73809   }
73810
73811   jresult = (int)result;
73812   return jresult;
73813 }
73814
73815
73816 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHeightPolicy(void * jarg1, int jarg2) {
73817   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73818   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy arg2 ;
73819
73820   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73821   arg2 = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)jarg2;
73822   {
73823     try {
73824       (arg1)->SetIndicatorHeightPolicy(arg2);
73825     } catch (std::out_of_range& e) {
73826       {
73827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73828       };
73829     } catch (std::exception& e) {
73830       {
73831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73832       };
73833     } catch (Dali::DaliException e) {
73834       {
73835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73836       };
73837     } catch (...) {
73838       {
73839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73840       };
73841     }
73842   }
73843
73844 }
73845
73846
73847 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHeightPolicy(void * jarg1) {
73848   int jresult ;
73849   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73850   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy result;
73851
73852   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73853   {
73854     try {
73855       result = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHeightPolicy();
73856     } catch (std::out_of_range& e) {
73857       {
73858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73859       };
73860     } catch (std::exception& e) {
73861       {
73862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73863       };
73864     } catch (Dali::DaliException e) {
73865       {
73866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73867       };
73868     } catch (...) {
73869       {
73870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73871       };
73872     }
73873   }
73874
73875   jresult = (int)result;
73876   return jresult;
73877 }
73878
73879
73880 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorFixedHeight(void * jarg1, float jarg2) {
73881   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73882   float arg2 ;
73883
73884   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73885   arg2 = (float)jarg2;
73886   {
73887     try {
73888       (arg1)->SetIndicatorFixedHeight(arg2);
73889     } catch (std::out_of_range& e) {
73890       {
73891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73892       };
73893     } catch (std::exception& e) {
73894       {
73895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73896       };
73897     } catch (Dali::DaliException e) {
73898       {
73899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73900       };
73901     } catch (...) {
73902       {
73903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73904       };
73905     }
73906   }
73907
73908 }
73909
73910
73911 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorFixedHeight(void * jarg1) {
73912   float jresult ;
73913   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73914   float result;
73915
73916   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73917   {
73918     try {
73919       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorFixedHeight();
73920     } catch (std::out_of_range& e) {
73921       {
73922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73923       };
73924     } catch (std::exception& e) {
73925       {
73926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73927       };
73928     } catch (Dali::DaliException e) {
73929       {
73930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73931       };
73932     } catch (...) {
73933       {
73934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73935       };
73936     }
73937   }
73938
73939   jresult = result;
73940   return jresult;
73941 }
73942
73943
73944 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorShowDuration(void * jarg1, float jarg2) {
73945   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73946   float arg2 ;
73947
73948   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73949   arg2 = (float)jarg2;
73950   {
73951     try {
73952       (arg1)->SetIndicatorShowDuration(arg2);
73953     } catch (std::out_of_range& e) {
73954       {
73955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73956       };
73957     } catch (std::exception& e) {
73958       {
73959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73960       };
73961     } catch (Dali::DaliException e) {
73962       {
73963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73964       };
73965     } catch (...) {
73966       {
73967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73968       };
73969     }
73970   }
73971
73972 }
73973
73974
73975 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorShowDuration(void * jarg1) {
73976   float jresult ;
73977   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73978   float result;
73979
73980   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73981   {
73982     try {
73983       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorShowDuration();
73984     } catch (std::out_of_range& e) {
73985       {
73986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73987       };
73988     } catch (std::exception& e) {
73989       {
73990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73991       };
73992     } catch (Dali::DaliException e) {
73993       {
73994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73995       };
73996     } catch (...) {
73997       {
73998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73999       };
74000     }
74001   }
74002
74003   jresult = result;
74004   return jresult;
74005 }
74006
74007
74008 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHideDuration(void * jarg1, float jarg2) {
74009   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
74010   float arg2 ;
74011
74012   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
74013   arg2 = (float)jarg2;
74014   {
74015     try {
74016       (arg1)->SetIndicatorHideDuration(arg2);
74017     } catch (std::out_of_range& e) {
74018       {
74019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74020       };
74021     } catch (std::exception& e) {
74022       {
74023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74024       };
74025     } catch (Dali::DaliException e) {
74026       {
74027         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74028       };
74029     } catch (...) {
74030       {
74031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74032       };
74033     }
74034   }
74035
74036 }
74037
74038
74039 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHideDuration(void * jarg1) {
74040   float jresult ;
74041   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
74042   float result;
74043
74044   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
74045   {
74046     try {
74047       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHideDuration();
74048     } catch (std::out_of_range& e) {
74049       {
74050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74051       };
74052     } catch (std::exception& e) {
74053       {
74054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74055       };
74056     } catch (Dali::DaliException e) {
74057       {
74058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74059       };
74060     } catch (...) {
74061       {
74062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74063       };
74064     }
74065   }
74066
74067   jresult = result;
74068   return jresult;
74069 }
74070
74071
74072 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_ShowIndicator(void * jarg1) {
74073   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
74074
74075   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
74076   {
74077     try {
74078       (arg1)->ShowIndicator();
74079     } catch (std::out_of_range& e) {
74080       {
74081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74082       };
74083     } catch (std::exception& e) {
74084       {
74085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74086       };
74087     } catch (Dali::DaliException e) {
74088       {
74089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74090       };
74091     } catch (...) {
74092       {
74093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74094       };
74095     }
74096   }
74097
74098 }
74099
74100
74101 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_HideIndicator(void * jarg1) {
74102   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
74103
74104   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
74105   {
74106     try {
74107       (arg1)->HideIndicator();
74108     } catch (std::out_of_range& e) {
74109       {
74110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74111       };
74112     } catch (std::exception& e) {
74113       {
74114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74115       };
74116     } catch (Dali::DaliException e) {
74117       {
74118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74119       };
74120     } catch (...) {
74121       {
74122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74123       };
74124     }
74125   }
74126
74127 }
74128
74129
74130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_PanFinishedSignal(void * jarg1) {
74131   void * jresult ;
74132   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
74133   Dali::Toolkit::ScrollBar::PanFinishedSignalType *result = 0 ;
74134
74135   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
74136   {
74137     try {
74138       result = (Dali::Toolkit::ScrollBar::PanFinishedSignalType *) &(arg1)->PanFinishedSignal();
74139     } catch (std::out_of_range& e) {
74140       {
74141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74142       };
74143     } catch (std::exception& e) {
74144       {
74145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74146       };
74147     } catch (Dali::DaliException e) {
74148       {
74149         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74150       };
74151     } catch (...) {
74152       {
74153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74154       };
74155     }
74156   }
74157
74158   jresult = (void *)result;
74159   return jresult;
74160 }
74161
74162
74163 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_ScrollPositionIntervalReachedSignal(void * jarg1) {
74164   void * jresult ;
74165   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
74166   Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *result = 0 ;
74167
74168   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
74169   {
74170     try {
74171       result = (Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *) &(arg1)->ScrollPositionIntervalReachedSignal();
74172     } catch (std::out_of_range& e) {
74173       {
74174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74175       };
74176     } catch (std::exception& e) {
74177       {
74178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74179       };
74180     } catch (Dali::DaliException e) {
74181       {
74182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74183       };
74184     } catch (...) {
74185       {
74186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74187       };
74188     }
74189   }
74190
74191   jresult = (void *)result;
74192   return jresult;
74193 }
74194
74195
74196 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_EFFECT_COLOR_get() {
74197   int jresult ;
74198   int result;
74199
74200   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_EFFECT_COLOR;
74201   jresult = (int)result;
74202   return jresult;
74203 }
74204
74205
74206 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ANIMATION_SPEED_get() {
74207   int jresult ;
74208   int result;
74209
74210   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ANIMATION_SPEED;
74211   jresult = (int)result;
74212   return jresult;
74213 }
74214
74215
74216 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ENABLED_get() {
74217   int jresult ;
74218   int result;
74219
74220   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ENABLED;
74221   jresult = (int)result;
74222   return jresult;
74223 }
74224
74225
74226 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_SIZE_get() {
74227   int jresult ;
74228   int result;
74229
74230   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_SIZE;
74231   jresult = (int)result;
74232   return jresult;
74233 }
74234
74235
74236 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_TO_ALPHA_FUNCTION_get() {
74237   int jresult ;
74238   int result;
74239
74240   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_TO_ALPHA_FUNCTION;
74241   jresult = (int)result;
74242   return jresult;
74243 }
74244
74245
74246 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_RELATIVE_POSITION_get() {
74247   int jresult ;
74248   int result;
74249
74250   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_RELATIVE_POSITION;
74251   jresult = (int)result;
74252   return jresult;
74253 }
74254
74255
74256 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_get() {
74257   int jresult ;
74258   int result;
74259
74260   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN;
74261   jresult = (int)result;
74262   return jresult;
74263 }
74264
74265
74266 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_X_get() {
74267   int jresult ;
74268   int result;
74269
74270   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_X;
74271   jresult = (int)result;
74272   return jresult;
74273 }
74274
74275
74276 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_Y_get() {
74277   int jresult ;
74278   int result;
74279
74280   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_Y;
74281   jresult = (int)result;
74282   return jresult;
74283 }
74284
74285
74286 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_get() {
74287   int jresult ;
74288   int result;
74289
74290   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX;
74291   jresult = (int)result;
74292   return jresult;
74293 }
74294
74295
74296 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_X_get() {
74297   int jresult ;
74298   int result;
74299
74300   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_X;
74301   jresult = (int)result;
74302   return jresult;
74303 }
74304
74305
74306 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_Y_get() {
74307   int jresult ;
74308   int result;
74309
74310   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_Y;
74311   jresult = (int)result;
74312   return jresult;
74313 }
74314
74315
74316 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_VERTICAL_get() {
74317   int jresult ;
74318   int result;
74319
74320   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_VERTICAL;
74321   jresult = (int)result;
74322   return jresult;
74323 }
74324
74325
74326 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_HORIZONTAL_get() {
74327   int jresult ;
74328   int result;
74329
74330   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_HORIZONTAL;
74331   jresult = (int)result;
74332   return jresult;
74333 }
74334
74335
74336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable_Property() {
74337   void * jresult ;
74338   Dali::Toolkit::Scrollable::Property *result = 0 ;
74339
74340   {
74341     try {
74342       result = (Dali::Toolkit::Scrollable::Property *)new Dali::Toolkit::Scrollable::Property();
74343     } catch (std::out_of_range& e) {
74344       {
74345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74346       };
74347     } catch (std::exception& e) {
74348       {
74349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74350       };
74351     } catch (Dali::DaliException e) {
74352       {
74353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74354       };
74355     } catch (...) {
74356       {
74357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74358       };
74359     }
74360   }
74361
74362   jresult = (void *)result;
74363   return jresult;
74364 }
74365
74366
74367 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable_Property(void * jarg1) {
74368   Dali::Toolkit::Scrollable::Property *arg1 = (Dali::Toolkit::Scrollable::Property *) 0 ;
74369
74370   arg1 = (Dali::Toolkit::Scrollable::Property *)jarg1;
74371   {
74372     try {
74373       delete arg1;
74374     } catch (std::out_of_range& e) {
74375       {
74376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74377       };
74378     } catch (std::exception& e) {
74379       {
74380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74381       };
74382     } catch (Dali::DaliException e) {
74383       {
74384         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74385       };
74386     } catch (...) {
74387       {
74388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74389       };
74390     }
74391   }
74392
74393 }
74394
74395
74396 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_0() {
74397   void * jresult ;
74398   Dali::Toolkit::Scrollable *result = 0 ;
74399
74400   {
74401     try {
74402       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable();
74403     } catch (std::out_of_range& e) {
74404       {
74405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74406       };
74407     } catch (std::exception& e) {
74408       {
74409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74410       };
74411     } catch (Dali::DaliException e) {
74412       {
74413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74414       };
74415     } catch (...) {
74416       {
74417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74418       };
74419     }
74420   }
74421
74422   jresult = (void *)result;
74423   return jresult;
74424 }
74425
74426
74427 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_1(void * jarg1) {
74428   void * jresult ;
74429   Dali::Toolkit::Scrollable *arg1 = 0 ;
74430   Dali::Toolkit::Scrollable *result = 0 ;
74431
74432   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74433   if (!arg1) {
74434     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
74435     return 0;
74436   }
74437   {
74438     try {
74439       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable((Dali::Toolkit::Scrollable const &)*arg1);
74440     } catch (std::out_of_range& e) {
74441       {
74442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74443       };
74444     } catch (std::exception& e) {
74445       {
74446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74447       };
74448     } catch (Dali::DaliException e) {
74449       {
74450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74451       };
74452     } catch (...) {
74453       {
74454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74455       };
74456     }
74457   }
74458
74459   jresult = (void *)result;
74460   return jresult;
74461 }
74462
74463
74464 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_Assign(void * jarg1, void * jarg2) {
74465   void * jresult ;
74466   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74467   Dali::Toolkit::Scrollable *arg2 = 0 ;
74468   Dali::Toolkit::Scrollable *result = 0 ;
74469
74470   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74471   arg2 = (Dali::Toolkit::Scrollable *)jarg2;
74472   if (!arg2) {
74473     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
74474     return 0;
74475   }
74476   {
74477     try {
74478       result = (Dali::Toolkit::Scrollable *) &(arg1)->operator =((Dali::Toolkit::Scrollable const &)*arg2);
74479     } catch (std::out_of_range& e) {
74480       {
74481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74482       };
74483     } catch (std::exception& e) {
74484       {
74485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74486       };
74487     } catch (Dali::DaliException e) {
74488       {
74489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74490       };
74491     } catch (...) {
74492       {
74493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74494       };
74495     }
74496   }
74497
74498   jresult = (void *)result;
74499   return jresult;
74500 }
74501
74502
74503 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable(void * jarg1) {
74504   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74505
74506   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74507   {
74508     try {
74509       delete arg1;
74510     } catch (std::out_of_range& e) {
74511       {
74512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74513       };
74514     } catch (std::exception& e) {
74515       {
74516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74517       };
74518     } catch (Dali::DaliException e) {
74519       {
74520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74521       };
74522     } catch (...) {
74523       {
74524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74525       };
74526     }
74527   }
74528
74529 }
74530
74531
74532 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_DownCast(void * jarg1) {
74533   void * jresult ;
74534   Dali::BaseHandle arg1 ;
74535   Dali::BaseHandle *argp1 ;
74536   Dali::Toolkit::Scrollable result;
74537
74538   argp1 = (Dali::BaseHandle *)jarg1;
74539   if (!argp1) {
74540     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
74541     return 0;
74542   }
74543   arg1 = *argp1;
74544   {
74545     try {
74546       result = Dali::Toolkit::Scrollable::DownCast(arg1);
74547     } catch (std::out_of_range& e) {
74548       {
74549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74550       };
74551     } catch (std::exception& e) {
74552       {
74553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74554       };
74555     } catch (Dali::DaliException e) {
74556       {
74557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74558       };
74559     } catch (...) {
74560       {
74561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74562       };
74563     }
74564   }
74565
74566   jresult = new Dali::Toolkit::Scrollable((const Dali::Toolkit::Scrollable &)result);
74567   return jresult;
74568 }
74569
74570
74571 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Scrollable_IsOvershootEnabled(void * jarg1) {
74572   unsigned int jresult ;
74573   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74574   bool result;
74575
74576   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74577   {
74578     try {
74579       result = (bool)((Dali::Toolkit::Scrollable const *)arg1)->IsOvershootEnabled();
74580     } catch (std::out_of_range& e) {
74581       {
74582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74583       };
74584     } catch (std::exception& e) {
74585       {
74586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74587       };
74588     } catch (Dali::DaliException e) {
74589       {
74590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74591       };
74592     } catch (...) {
74593       {
74594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74595       };
74596     }
74597   }
74598
74599   jresult = result;
74600   return jresult;
74601 }
74602
74603
74604 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEnabled(void * jarg1, unsigned int jarg2) {
74605   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74606   bool arg2 ;
74607
74608   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74609   arg2 = jarg2 ? true : false;
74610   {
74611     try {
74612       (arg1)->SetOvershootEnabled(arg2);
74613     } catch (std::out_of_range& e) {
74614       {
74615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74616       };
74617     } catch (std::exception& e) {
74618       {
74619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74620       };
74621     } catch (Dali::DaliException e) {
74622       {
74623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74624       };
74625     } catch (...) {
74626       {
74627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74628       };
74629     }
74630   }
74631
74632 }
74633
74634
74635 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEffectColor(void * jarg1, void * jarg2) {
74636   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74637   Dali::Vector4 *arg2 = 0 ;
74638
74639   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74640   arg2 = (Dali::Vector4 *)jarg2;
74641   if (!arg2) {
74642     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
74643     return ;
74644   }
74645   {
74646     try {
74647       (arg1)->SetOvershootEffectColor((Dali::Vector4 const &)*arg2);
74648     } catch (std::out_of_range& e) {
74649       {
74650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74651       };
74652     } catch (std::exception& e) {
74653       {
74654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74655       };
74656     } catch (Dali::DaliException e) {
74657       {
74658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74659       };
74660     } catch (...) {
74661       {
74662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74663       };
74664     }
74665   }
74666
74667 }
74668
74669
74670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootEffectColor(void * jarg1) {
74671   void * jresult ;
74672   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74673   Dali::Vector4 result;
74674
74675   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74676   {
74677     try {
74678       result = ((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootEffectColor();
74679     } catch (std::out_of_range& e) {
74680       {
74681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74682       };
74683     } catch (std::exception& e) {
74684       {
74685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74686       };
74687     } catch (Dali::DaliException e) {
74688       {
74689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74690       };
74691     } catch (...) {
74692       {
74693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74694       };
74695     }
74696   }
74697
74698   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
74699   return jresult;
74700 }
74701
74702
74703 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootAnimationSpeed(void * jarg1, float jarg2) {
74704   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74705   float arg2 ;
74706
74707   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74708   arg2 = (float)jarg2;
74709   {
74710     try {
74711       (arg1)->SetOvershootAnimationSpeed(arg2);
74712     } catch (std::out_of_range& e) {
74713       {
74714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74715       };
74716     } catch (std::exception& e) {
74717       {
74718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74719       };
74720     } catch (Dali::DaliException e) {
74721       {
74722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74723       };
74724     } catch (...) {
74725       {
74726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74727       };
74728     }
74729   }
74730
74731 }
74732
74733
74734 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootAnimationSpeed(void * jarg1) {
74735   float jresult ;
74736   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74737   float result;
74738
74739   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74740   {
74741     try {
74742       result = (float)((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootAnimationSpeed();
74743     } catch (std::out_of_range& e) {
74744       {
74745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74746       };
74747     } catch (std::exception& e) {
74748       {
74749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74750       };
74751     } catch (Dali::DaliException e) {
74752       {
74753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74754       };
74755     } catch (...) {
74756       {
74757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74758       };
74759     }
74760   }
74761
74762   jresult = result;
74763   return jresult;
74764 }
74765
74766
74767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollStartedSignal(void * jarg1) {
74768   void * jresult ;
74769   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74770   Dali::Toolkit::Scrollable::ScrollStartedSignalType *result = 0 ;
74771
74772   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74773   {
74774     try {
74775       result = (Dali::Toolkit::Scrollable::ScrollStartedSignalType *) &(arg1)->ScrollStartedSignal();
74776     } catch (std::out_of_range& e) {
74777       {
74778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74779       };
74780     } catch (std::exception& e) {
74781       {
74782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74783       };
74784     } catch (Dali::DaliException e) {
74785       {
74786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74787       };
74788     } catch (...) {
74789       {
74790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74791       };
74792     }
74793   }
74794
74795   jresult = (void *)result;
74796   return jresult;
74797 }
74798
74799
74800 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollUpdatedSignal(void * jarg1) {
74801   void * jresult ;
74802   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74803   Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *result = 0 ;
74804
74805   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74806   {
74807     try {
74808       result = (Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *) &(arg1)->ScrollUpdatedSignal();
74809     } catch (std::out_of_range& e) {
74810       {
74811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74812       };
74813     } catch (std::exception& e) {
74814       {
74815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74816       };
74817     } catch (Dali::DaliException e) {
74818       {
74819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74820       };
74821     } catch (...) {
74822       {
74823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74824       };
74825     }
74826   }
74827
74828   jresult = (void *)result;
74829   return jresult;
74830 }
74831
74832
74833 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollCompletedSignal(void * jarg1) {
74834   void * jresult ;
74835   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74836   Dali::Toolkit::Scrollable::ScrollCompletedSignalType *result = 0 ;
74837
74838   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74839   {
74840     try {
74841       result = (Dali::Toolkit::Scrollable::ScrollCompletedSignalType *) &(arg1)->ScrollCompletedSignal();
74842     } catch (std::out_of_range& e) {
74843       {
74844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74845       };
74846     } catch (std::exception& e) {
74847       {
74848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74849       };
74850     } catch (Dali::DaliException e) {
74851       {
74852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74853       };
74854     } catch (...) {
74855       {
74856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74857       };
74858     }
74859   }
74860
74861   jresult = (void *)result;
74862   return jresult;
74863 }
74864
74865
74866 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsVertical(int jarg1) {
74867   unsigned int jresult ;
74868   Dali::Toolkit::ControlOrientation::Type arg1 ;
74869   bool result;
74870
74871   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
74872   {
74873     try {
74874       result = (bool)Dali::Toolkit::IsVertical(arg1);
74875     } catch (std::out_of_range& e) {
74876       {
74877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74878       };
74879     } catch (std::exception& e) {
74880       {
74881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74882       };
74883     } catch (Dali::DaliException e) {
74884       {
74885         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74886       };
74887     } catch (...) {
74888       {
74889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74890       };
74891     }
74892   }
74893
74894   jresult = result;
74895   return jresult;
74896 }
74897
74898
74899 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsHorizontal(int jarg1) {
74900   unsigned int jresult ;
74901   Dali::Toolkit::ControlOrientation::Type arg1 ;
74902   bool result;
74903
74904   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
74905   {
74906     try {
74907       result = (bool)Dali::Toolkit::IsHorizontal(arg1);
74908     } catch (std::out_of_range& e) {
74909       {
74910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74911       };
74912     } catch (std::exception& e) {
74913       {
74914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74915       };
74916     } catch (Dali::DaliException e) {
74917       {
74918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74919       };
74920     } catch (...) {
74921       {
74922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74923       };
74924     }
74925   }
74926
74927   jresult = result;
74928   return jresult;
74929 }
74930
74931
74932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_0(unsigned int jarg1, unsigned int jarg2) {
74933   void * jresult ;
74934   unsigned int arg1 ;
74935   unsigned int arg2 ;
74936   Dali::Toolkit::ItemRange *result = 0 ;
74937
74938   arg1 = (unsigned int)jarg1;
74939   arg2 = (unsigned int)jarg2;
74940   {
74941     try {
74942       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange(arg1,arg2);
74943     } catch (std::out_of_range& e) {
74944       {
74945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74946       };
74947     } catch (std::exception& e) {
74948       {
74949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74950       };
74951     } catch (Dali::DaliException e) {
74952       {
74953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74954       };
74955     } catch (...) {
74956       {
74957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74958       };
74959     }
74960   }
74961
74962   jresult = (void *)result;
74963   return jresult;
74964 }
74965
74966
74967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_1(void * jarg1) {
74968   void * jresult ;
74969   Dali::Toolkit::ItemRange *arg1 = 0 ;
74970   Dali::Toolkit::ItemRange *result = 0 ;
74971
74972   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74973   if (!arg1) {
74974     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
74975     return 0;
74976   }
74977   {
74978     try {
74979       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange((Dali::Toolkit::ItemRange const &)*arg1);
74980     } catch (std::out_of_range& e) {
74981       {
74982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74983       };
74984     } catch (std::exception& e) {
74985       {
74986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74987       };
74988     } catch (Dali::DaliException e) {
74989       {
74990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74991       };
74992     } catch (...) {
74993       {
74994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74995       };
74996     }
74997   }
74998
74999   jresult = (void *)result;
75000   return jresult;
75001 }
75002
75003
75004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Assign(void * jarg1, void * jarg2) {
75005   void * jresult ;
75006   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
75007   Dali::Toolkit::ItemRange *arg2 = 0 ;
75008   Dali::Toolkit::ItemRange *result = 0 ;
75009
75010   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
75011   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
75012   if (!arg2) {
75013     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
75014     return 0;
75015   }
75016   {
75017     try {
75018       result = (Dali::Toolkit::ItemRange *) &(arg1)->operator =((Dali::Toolkit::ItemRange const &)*arg2);
75019     } catch (std::out_of_range& e) {
75020       {
75021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75022       };
75023     } catch (std::exception& e) {
75024       {
75025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75026       };
75027     } catch (Dali::DaliException e) {
75028       {
75029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75030       };
75031     } catch (...) {
75032       {
75033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75034       };
75035     }
75036   }
75037
75038   jresult = (void *)result;
75039   return jresult;
75040 }
75041
75042
75043 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_Within(void * jarg1, unsigned int jarg2) {
75044   unsigned int jresult ;
75045   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
75046   unsigned int arg2 ;
75047   bool result;
75048
75049   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
75050   arg2 = (unsigned int)jarg2;
75051   {
75052     try {
75053       result = (bool)(arg1)->Within(arg2);
75054     } catch (std::out_of_range& e) {
75055       {
75056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75057       };
75058     } catch (std::exception& e) {
75059       {
75060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75061       };
75062     } catch (Dali::DaliException e) {
75063       {
75064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75065       };
75066     } catch (...) {
75067       {
75068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75069       };
75070     }
75071   }
75072
75073   jresult = result;
75074   return jresult;
75075 }
75076
75077
75078 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Intersection(void * jarg1, void * jarg2) {
75079   void * jresult ;
75080   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
75081   Dali::Toolkit::ItemRange *arg2 = 0 ;
75082   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
75083
75084   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
75085   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
75086   if (!arg2) {
75087     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
75088     return 0;
75089   }
75090   {
75091     try {
75092       result = (arg1)->Intersection((Dali::Toolkit::ItemRange const &)*arg2);
75093     } catch (std::out_of_range& e) {
75094       {
75095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75096       };
75097     } catch (std::exception& e) {
75098       {
75099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75100       };
75101     } catch (Dali::DaliException e) {
75102       {
75103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75104       };
75105     } catch (...) {
75106       {
75107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75108       };
75109     }
75110   }
75111
75112   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
75113   return jresult;
75114 }
75115
75116
75117 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_begin_set(void * jarg1, unsigned int jarg2) {
75118   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
75119   unsigned int arg2 ;
75120
75121   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
75122   arg2 = (unsigned int)jarg2;
75123   if (arg1) (arg1)->begin = arg2;
75124 }
75125
75126
75127 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_begin_get(void * jarg1) {
75128   unsigned int jresult ;
75129   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
75130   unsigned int result;
75131
75132   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
75133   result = (unsigned int) ((arg1)->begin);
75134   jresult = result;
75135   return jresult;
75136 }
75137
75138
75139 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_end_set(void * jarg1, unsigned int jarg2) {
75140   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
75141   unsigned int arg2 ;
75142
75143   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
75144   arg2 = (unsigned int)jarg2;
75145   if (arg1) (arg1)->end = arg2;
75146 }
75147
75148
75149 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_end_get(void * jarg1) {
75150   unsigned int jresult ;
75151   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
75152   unsigned int result;
75153
75154   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
75155   result = (unsigned int) ((arg1)->end);
75156   jresult = result;
75157   return jresult;
75158 }
75159
75160
75161 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemRange(void * jarg1) {
75162   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
75163
75164   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
75165   {
75166     try {
75167       delete arg1;
75168     } catch (std::out_of_range& e) {
75169       {
75170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75171       };
75172     } catch (std::exception& e) {
75173       {
75174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75175       };
75176     } catch (Dali::DaliException e) {
75177       {
75178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75179       };
75180     } catch (...) {
75181       {
75182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75183       };
75184     }
75185   }
75186
75187 }
75188
75189
75190 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemLayout(void * jarg1) {
75191   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75192
75193   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75194   {
75195     try {
75196       delete arg1;
75197     } catch (std::out_of_range& e) {
75198       {
75199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75200       };
75201     } catch (std::exception& e) {
75202       {
75203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75204       };
75205     } catch (Dali::DaliException e) {
75206       {
75207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75208       };
75209     } catch (...) {
75210       {
75211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75212       };
75213     }
75214   }
75215
75216 }
75217
75218
75219 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetOrientation(void * jarg1, int jarg2) {
75220   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75221   Dali::Toolkit::ControlOrientation::Type arg2 ;
75222
75223   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75224   arg2 = (Dali::Toolkit::ControlOrientation::Type)jarg2;
75225   {
75226     try {
75227       (arg1)->SetOrientation(arg2);
75228     } catch (std::out_of_range& e) {
75229       {
75230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75231       };
75232     } catch (std::exception& e) {
75233       {
75234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75235       };
75236     } catch (Dali::DaliException e) {
75237       {
75238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75239       };
75240     } catch (...) {
75241       {
75242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75243       };
75244     }
75245   }
75246
75247 }
75248
75249
75250 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetOrientation(void * jarg1) {
75251   int jresult ;
75252   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75253   Dali::Toolkit::ControlOrientation::Type result;
75254
75255   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75256   {
75257     try {
75258       result = (Dali::Toolkit::ControlOrientation::Type)((Dali::Toolkit::ItemLayout const *)arg1)->GetOrientation();
75259     } catch (std::out_of_range& e) {
75260       {
75261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75262       };
75263     } catch (std::exception& e) {
75264       {
75265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75266       };
75267     } catch (Dali::DaliException e) {
75268       {
75269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75270       };
75271     } catch (...) {
75272       {
75273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75274       };
75275     }
75276   }
75277
75278   jresult = (int)result;
75279   return jresult;
75280 }
75281
75282
75283 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetLayoutProperties(void * jarg1, void * jarg2) {
75284   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75285   Dali::Property::Map *arg2 = 0 ;
75286
75287   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75288   arg2 = (Dali::Property::Map *)jarg2;
75289   if (!arg2) {
75290     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
75291     return ;
75292   }
75293   {
75294     try {
75295       (arg1)->SetLayoutProperties((Dali::Property::Map const &)*arg2);
75296     } catch (std::out_of_range& e) {
75297       {
75298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75299       };
75300     } catch (std::exception& e) {
75301       {
75302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75303       };
75304     } catch (Dali::DaliException e) {
75305       {
75306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75307       };
75308     } catch (...) {
75309       {
75310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75311       };
75312     }
75313   }
75314
75315 }
75316
75317
75318 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetLayoutProperties(void * jarg1) {
75319   void * jresult ;
75320   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75321   Dali::Property::Map result;
75322
75323   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75324   {
75325     try {
75326       result = (arg1)->GetLayoutProperties();
75327     } catch (std::out_of_range& e) {
75328       {
75329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75330       };
75331     } catch (std::exception& e) {
75332       {
75333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75334       };
75335     } catch (Dali::DaliException e) {
75336       {
75337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75338       };
75339     } catch (...) {
75340       {
75341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75342       };
75343     }
75344   }
75345
75346   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
75347   return jresult;
75348 }
75349
75350
75351 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
75352   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75353   unsigned int arg2 ;
75354   Dali::Vector3 *arg3 = 0 ;
75355   Dali::Vector3 *arg4 = 0 ;
75356
75357   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75358   arg2 = (unsigned int)jarg2;
75359   arg3 = (Dali::Vector3 *)jarg3;
75360   if (!arg3) {
75361     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75362     return ;
75363   }
75364   arg4 = (Dali::Vector3 *)jarg4;
75365   if (!arg4) {
75366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
75367     return ;
75368   }
75369   {
75370     try {
75371       ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
75372     } catch (std::out_of_range& e) {
75373       {
75374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75375       };
75376     } catch (std::exception& e) {
75377       {
75378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75379       };
75380     } catch (Dali::DaliException e) {
75381       {
75382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75383       };
75384     } catch (...) {
75385       {
75386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75387       };
75388     }
75389   }
75390
75391 }
75392
75393
75394 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetItemSize(void * jarg1, void * jarg2) {
75395   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75396   Dali::Vector3 *arg2 = 0 ;
75397
75398   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75399   arg2 = (Dali::Vector3 *)jarg2;
75400   if (!arg2) {
75401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75402     return ;
75403   }
75404   {
75405     try {
75406       (arg1)->SetItemSize((Dali::Vector3 const &)*arg2);
75407     } catch (std::out_of_range& e) {
75408       {
75409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75410       };
75411     } catch (std::exception& e) {
75412       {
75413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75414       };
75415     } catch (Dali::DaliException e) {
75416       {
75417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75418       };
75419     } catch (...) {
75420       {
75421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75422       };
75423     }
75424   }
75425
75426 }
75427
75428
75429 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMinimumLayoutPosition(void * jarg1, unsigned int jarg2, void * jarg3) {
75430   float jresult ;
75431   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75432   unsigned int arg2 ;
75433   Dali::Vector3 arg3 ;
75434   Dali::Vector3 *argp3 ;
75435   float result;
75436
75437   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75438   arg2 = (unsigned int)jarg2;
75439   argp3 = (Dali::Vector3 *)jarg3;
75440   if (!argp3) {
75441     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
75442     return 0;
75443   }
75444   arg3 = *argp3;
75445   {
75446     try {
75447       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMinimumLayoutPosition(arg2,arg3);
75448     } catch (std::out_of_range& e) {
75449       {
75450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75451       };
75452     } catch (std::exception& e) {
75453       {
75454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75455       };
75456     } catch (Dali::DaliException e) {
75457       {
75458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75459       };
75460     } catch (...) {
75461       {
75462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75463       };
75464     }
75465   }
75466
75467   jresult = result;
75468   return jresult;
75469 }
75470
75471
75472 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestAnchorPosition(void * jarg1, float jarg2) {
75473   float jresult ;
75474   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75475   float arg2 ;
75476   float result;
75477
75478   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75479   arg2 = (float)jarg2;
75480   {
75481     try {
75482       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetClosestAnchorPosition(arg2);
75483     } catch (std::out_of_range& e) {
75484       {
75485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75486       };
75487     } catch (std::exception& e) {
75488       {
75489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75490       };
75491     } catch (Dali::DaliException e) {
75492       {
75493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75494       };
75495     } catch (...) {
75496       {
75497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75498       };
75499     }
75500   }
75501
75502   jresult = result;
75503   return jresult;
75504 }
75505
75506
75507 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemScrollToPosition(void * jarg1, unsigned int jarg2) {
75508   float jresult ;
75509   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75510   unsigned int arg2 ;
75511   float result;
75512
75513   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75514   arg2 = (unsigned int)jarg2;
75515   {
75516     try {
75517       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemScrollToPosition(arg2);
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 = result;
75538   return jresult;
75539 }
75540
75541
75542 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemsWithinArea(void * jarg1, float jarg2, void * jarg3) {
75543   void * jresult ;
75544   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75545   float arg2 ;
75546   Dali::Vector3 arg3 ;
75547   Dali::Vector3 *argp3 ;
75548   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
75549
75550   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75551   arg2 = (float)jarg2;
75552   argp3 = (Dali::Vector3 *)jarg3;
75553   if (!argp3) {
75554     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
75555     return 0;
75556   }
75557   arg3 = *argp3;
75558   {
75559     try {
75560       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemsWithinArea(arg2,arg3);
75561     } catch (std::out_of_range& e) {
75562       {
75563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75564       };
75565     } catch (std::exception& e) {
75566       {
75567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75568       };
75569     } catch (Dali::DaliException e) {
75570       {
75571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75572       };
75573     } catch (...) {
75574       {
75575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75576       };
75577     }
75578   }
75579
75580   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
75581   return jresult;
75582 }
75583
75584
75585 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestOnScreenLayoutPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
75586   float jresult ;
75587   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75588   int arg2 ;
75589   float arg3 ;
75590   Dali::Vector3 *arg4 = 0 ;
75591   float result;
75592
75593   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75594   arg2 = (int)jarg2;
75595   arg3 = (float)jarg3;
75596   arg4 = (Dali::Vector3 *)jarg4;
75597   if (!arg4) {
75598     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75599     return 0;
75600   }
75601   {
75602     try {
75603       result = (float)(arg1)->GetClosestOnScreenLayoutPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
75604     } catch (std::out_of_range& e) {
75605       {
75606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75607       };
75608     } catch (std::exception& e) {
75609       {
75610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75611       };
75612     } catch (Dali::DaliException e) {
75613       {
75614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75615       };
75616     } catch (...) {
75617       {
75618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75619       };
75620     }
75621   }
75622
75623   jresult = result;
75624   return jresult;
75625 }
75626
75627
75628 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemLayout_GetReserveItemCount(void * jarg1, void * jarg2) {
75629   unsigned int jresult ;
75630   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75631   Dali::Vector3 arg2 ;
75632   Dali::Vector3 *argp2 ;
75633   unsigned int result;
75634
75635   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75636   argp2 = (Dali::Vector3 *)jarg2;
75637   if (!argp2) {
75638     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
75639     return 0;
75640   }
75641   arg2 = *argp2;
75642   {
75643     try {
75644       result = (unsigned int)((Dali::Toolkit::ItemLayout const *)arg1)->GetReserveItemCount(arg2);
75645     } catch (std::out_of_range& e) {
75646       {
75647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75648       };
75649     } catch (std::exception& e) {
75650       {
75651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75652       };
75653     } catch (Dali::DaliException e) {
75654       {
75655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75656       };
75657     } catch (...) {
75658       {
75659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75660       };
75661     }
75662   }
75663
75664   jresult = result;
75665   return jresult;
75666 }
75667
75668
75669 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetDefaultItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
75670   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75671   unsigned int arg2 ;
75672   Dali::Vector3 *arg3 = 0 ;
75673   Dali::Vector3 *arg4 = 0 ;
75674
75675   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75676   arg2 = (unsigned int)jarg2;
75677   arg3 = (Dali::Vector3 *)jarg3;
75678   if (!arg3) {
75679     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75680     return ;
75681   }
75682   arg4 = (Dali::Vector3 *)jarg4;
75683   if (!arg4) {
75684     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
75685     return ;
75686   }
75687   {
75688     try {
75689       ((Dali::Toolkit::ItemLayout const *)arg1)->GetDefaultItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
75690     } catch (std::out_of_range& e) {
75691       {
75692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75693       };
75694     } catch (std::exception& e) {
75695       {
75696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75697       };
75698     } catch (Dali::DaliException e) {
75699       {
75700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75701       };
75702     } catch (...) {
75703       {
75704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75705       };
75706     }
75707   }
75708
75709 }
75710
75711
75712 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollDirection(void * jarg1) {
75713   void * jresult ;
75714   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75715   Dali::Degree result;
75716
75717   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75718   {
75719     try {
75720       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollDirection();
75721     } catch (std::out_of_range& e) {
75722       {
75723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75724       };
75725     } catch (std::exception& e) {
75726       {
75727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75728       };
75729     } catch (Dali::DaliException e) {
75730       {
75731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75732       };
75733     } catch (...) {
75734       {
75735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75736       };
75737     }
75738   }
75739
75740   jresult = new Dali::Degree((const Dali::Degree &)result);
75741   return jresult;
75742 }
75743
75744
75745 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollSpeedFactor(void * jarg1) {
75746   float jresult ;
75747   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75748   float result;
75749
75750   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75751   {
75752     try {
75753       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollSpeedFactor();
75754     } catch (std::out_of_range& e) {
75755       {
75756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75757       };
75758     } catch (std::exception& e) {
75759       {
75760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75761       };
75762     } catch (Dali::DaliException e) {
75763       {
75764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75765       };
75766     } catch (...) {
75767       {
75768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75769       };
75770     }
75771   }
75772
75773   jresult = result;
75774   return jresult;
75775 }
75776
75777
75778 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMaximumSwipeSpeed(void * jarg1) {
75779   float jresult ;
75780   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75781   float result;
75782
75783   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75784   {
75785     try {
75786       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMaximumSwipeSpeed();
75787     } catch (std::out_of_range& e) {
75788       {
75789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75790       };
75791     } catch (std::exception& e) {
75792       {
75793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75794       };
75795     } catch (Dali::DaliException e) {
75796       {
75797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75798       };
75799     } catch (...) {
75800       {
75801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75802       };
75803     }
75804   }
75805
75806   jresult = result;
75807   return jresult;
75808 }
75809
75810
75811 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemFlickAnimationDuration(void * jarg1) {
75812   float jresult ;
75813   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75814   float result;
75815
75816   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75817   {
75818     try {
75819       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemFlickAnimationDuration();
75820     } catch (std::out_of_range& e) {
75821       {
75822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75823       };
75824     } catch (std::exception& e) {
75825       {
75826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75827       };
75828     } catch (Dali::DaliException e) {
75829       {
75830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75831       };
75832     } catch (...) {
75833       {
75834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75835       };
75836     }
75837   }
75838
75839   jresult = result;
75840   return jresult;
75841 }
75842
75843
75844 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetNextFocusItemID(void * jarg1, int jarg2, int jarg3, int jarg4, unsigned int jarg5) {
75845   int jresult ;
75846   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75847   int arg2 ;
75848   int arg3 ;
75849   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
75850   bool arg5 ;
75851   int result;
75852
75853   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75854   arg2 = (int)jarg2;
75855   arg3 = (int)jarg3;
75856   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
75857   arg5 = jarg5 ? true : false;
75858   {
75859     try {
75860       result = (int)(arg1)->GetNextFocusItemID(arg2,arg3,arg4,arg5);
75861     } catch (std::out_of_range& e) {
75862       {
75863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75864       };
75865     } catch (std::exception& e) {
75866       {
75867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75868       };
75869     } catch (Dali::DaliException e) {
75870       {
75871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75872       };
75873     } catch (...) {
75874       {
75875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75876       };
75877     }
75878   }
75879
75880   jresult = result;
75881   return jresult;
75882 }
75883
75884
75885 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetFlickSpeedFactor(void * jarg1) {
75886   float jresult ;
75887   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75888   float result;
75889
75890   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75891   {
75892     try {
75893       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetFlickSpeedFactor();
75894     } catch (std::out_of_range& e) {
75895       {
75896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75897       };
75898     } catch (std::exception& e) {
75899       {
75900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75901       };
75902     } catch (Dali::DaliException e) {
75903       {
75904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75905       };
75906     } catch (...) {
75907       {
75908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75909       };
75910     }
75911   }
75912
75913   jresult = result;
75914   return jresult;
75915 }
75916
75917
75918 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_ApplyConstraints(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5) {
75919   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75920   Dali::Actor *arg2 = 0 ;
75921   int arg3 ;
75922   Dali::Vector3 *arg4 = 0 ;
75923   Dali::Actor *arg5 = 0 ;
75924
75925   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75926   arg2 = (Dali::Actor *)jarg2;
75927   if (!arg2) {
75928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
75929     return ;
75930   }
75931   arg3 = (int)jarg3;
75932   arg4 = (Dali::Vector3 *)jarg4;
75933   if (!arg4) {
75934     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75935     return ;
75936   }
75937   arg5 = (Dali::Actor *)jarg5;
75938   if (!arg5) {
75939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
75940     return ;
75941   }
75942   {
75943     try {
75944       (arg1)->ApplyConstraints(*arg2,arg3,(Dali::Vector3 const &)*arg4,(Dali::Actor const &)*arg5);
75945     } catch (std::out_of_range& e) {
75946       {
75947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75948       };
75949     } catch (std::exception& e) {
75950       {
75951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75952       };
75953     } catch (Dali::DaliException e) {
75954       {
75955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75956       };
75957     } catch (...) {
75958       {
75959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75960       };
75961     }
75962   }
75963
75964 }
75965
75966
75967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
75968   void * jresult ;
75969   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75970   int arg2 ;
75971   float arg3 ;
75972   Dali::Vector3 *arg4 = 0 ;
75973   Dali::Vector3 result;
75974
75975   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75976   arg2 = (int)jarg2;
75977   arg3 = (float)jarg3;
75978   arg4 = (Dali::Vector3 *)jarg4;
75979   if (!arg4) {
75980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75981     return 0;
75982   }
75983   {
75984     try {
75985       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
75986     } catch (std::out_of_range& e) {
75987       {
75988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75989       };
75990     } catch (std::exception& e) {
75991       {
75992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75993       };
75994     } catch (Dali::DaliException e) {
75995       {
75996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75997       };
75998     } catch (...) {
75999       {
76000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76001       };
76002     }
76003   }
76004
76005   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
76006   return jresult;
76007 }
76008
76009
76010 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NewItemLayout(int jarg1) {
76011   void * jresult ;
76012   Dali::Toolkit::DefaultItemLayout::Type arg1 ;
76013   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
76014
76015   arg1 = (Dali::Toolkit::DefaultItemLayout::Type)jarg1;
76016   {
76017     try {
76018       result = Dali::Toolkit::DefaultItemLayout::New(arg1);
76019     } catch (std::out_of_range& e) {
76020       {
76021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76022       };
76023     } catch (std::exception& e) {
76024       {
76025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76026       };
76027     } catch (Dali::DaliException e) {
76028       {
76029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76030       };
76031     } catch (...) {
76032       {
76033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76034       };
76035     }
76036   }
76037
76038   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
76039   return jresult;
76040 }
76041
76042
76043 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemFactory(void * jarg1) {
76044   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
76045
76046   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
76047   {
76048     try {
76049       delete arg1;
76050     } catch (std::out_of_range& e) {
76051       {
76052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76053       };
76054     } catch (std::exception& e) {
76055       {
76056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76057       };
76058     } catch (Dali::DaliException e) {
76059       {
76060         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76061       };
76062     } catch (...) {
76063       {
76064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76065       };
76066     }
76067   }
76068
76069 }
76070
76071
76072 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemFactory_GetNumberOfItems(void * jarg1) {
76073   unsigned int jresult ;
76074   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
76075   unsigned int result;
76076
76077   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
76078   {
76079     try {
76080       result = (unsigned int)(arg1)->GetNumberOfItems();
76081     } catch (std::out_of_range& e) {
76082       {
76083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76084       };
76085     } catch (std::exception& e) {
76086       {
76087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76088       };
76089     } catch (Dali::DaliException e) {
76090       {
76091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76092       };
76093     } catch (...) {
76094       {
76095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76096       };
76097     }
76098   }
76099
76100   jresult = result;
76101   return jresult;
76102 }
76103
76104
76105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemFactory_NewItem(void * jarg1, unsigned int jarg2) {
76106   void * jresult ;
76107   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
76108   unsigned int arg2 ;
76109   Dali::Actor result;
76110
76111   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
76112   arg2 = (unsigned int)jarg2;
76113   {
76114     try {
76115       result = (arg1)->NewItem(arg2);
76116     } catch (std::out_of_range& e) {
76117       {
76118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76119       };
76120     } catch (std::exception& e) {
76121       {
76122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76123       };
76124     } catch (Dali::DaliException e) {
76125       {
76126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76127       };
76128     } catch (...) {
76129       {
76130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76131       };
76132     }
76133   }
76134
76135   jresult = new Dali::Actor((const Dali::Actor &)result);
76136   return jresult;
76137 }
76138
76139
76140 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleased(void * jarg1, unsigned int jarg2, void * jarg3) {
76141   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
76142   unsigned int arg2 ;
76143   Dali::Actor arg3 ;
76144   Dali::Actor *argp3 ;
76145
76146   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
76147   arg2 = (unsigned int)jarg2;
76148   argp3 = (Dali::Actor *)jarg3;
76149   if (!argp3) {
76150     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76151     return ;
76152   }
76153   arg3 = *argp3;
76154   {
76155     try {
76156       (arg1)->ItemReleased(arg2,arg3);
76157     } catch (std::out_of_range& e) {
76158       {
76159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76160       };
76161     } catch (std::exception& e) {
76162       {
76163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76164       };
76165     } catch (Dali::DaliException e) {
76166       {
76167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76168       };
76169     } catch (...) {
76170       {
76171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76172       };
76173     }
76174   }
76175
76176 }
76177
76178
76179 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleasedSwigExplicitItemFactory(void * jarg1, unsigned int jarg2, void * jarg3) {
76180   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
76181   unsigned int arg2 ;
76182   Dali::Actor arg3 ;
76183   Dali::Actor *argp3 ;
76184
76185   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
76186   arg2 = (unsigned int)jarg2;
76187   argp3 = (Dali::Actor *)jarg3;
76188   if (!argp3) {
76189     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76190     return ;
76191   }
76192   arg3 = *argp3;
76193   {
76194     try {
76195       (arg1)->Dali::Toolkit::ItemFactory::ItemReleased(arg2,arg3);
76196     } catch (std::out_of_range& e) {
76197       {
76198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76199       };
76200     } catch (std::exception& e) {
76201       {
76202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76203       };
76204     } catch (Dali::DaliException e) {
76205       {
76206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76207       };
76208     } catch (...) {
76209       {
76210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76211       };
76212     }
76213   }
76214
76215 }
76216
76217
76218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemFactory() {
76219   void * jresult ;
76220   Dali::Toolkit::ItemFactory *result = 0 ;
76221
76222   {
76223     try {
76224       result = (Dali::Toolkit::ItemFactory *)new SwigDirector_ItemFactory();
76225     } catch (std::out_of_range& e) {
76226       {
76227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76228       };
76229     } catch (std::exception& e) {
76230       {
76231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76232       };
76233     } catch (Dali::DaliException e) {
76234       {
76235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76236       };
76237     } catch (...) {
76238       {
76239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76240       };
76241     }
76242   }
76243
76244   jresult = (void *)result;
76245   return jresult;
76246 }
76247
76248
76249 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) {
76250   Dali::Toolkit::ItemFactory *obj = (Dali::Toolkit::ItemFactory *)objarg;
76251   SwigDirector_ItemFactory *director = dynamic_cast<SwigDirector_ItemFactory *>(obj);
76252   if (director) {
76253     director->swig_connect_director(callback0, callback1, callback2);
76254   }
76255 }
76256
76257
76258 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_SPEED_get() {
76259   int jresult ;
76260   int result;
76261
76262   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_SPEED;
76263   jresult = (int)result;
76264   return jresult;
76265 }
76266
76267
76268 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_DISTANCE_get() {
76269   int jresult ;
76270   int result;
76271
76272   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_DISTANCE;
76273   jresult = (int)result;
76274   return jresult;
76275 }
76276
76277
76278 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
76279   int jresult ;
76280   int result;
76281
76282   result = (int)Dali::Toolkit::ItemView::Property::WHEEL_SCROLL_DISTANCE_STEP;
76283   jresult = (int)result;
76284   return jresult;
76285 }
76286
76287
76288 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SNAP_TO_ITEM_ENABLED_get() {
76289   int jresult ;
76290   int result;
76291
76292   result = (int)Dali::Toolkit::ItemView::Property::SNAP_TO_ITEM_ENABLED;
76293   jresult = (int)result;
76294   return jresult;
76295 }
76296
76297
76298 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_REFRESH_INTERVAL_get() {
76299   int jresult ;
76300   int result;
76301
76302   result = (int)Dali::Toolkit::ItemView::Property::REFRESH_INTERVAL;
76303   jresult = (int)result;
76304   return jresult;
76305 }
76306
76307
76308 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_POSITION_get() {
76309   int jresult ;
76310   int result;
76311
76312   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_POSITION;
76313   jresult = (int)result;
76314   return jresult;
76315 }
76316
76317
76318 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_SPEED_get() {
76319   int jresult ;
76320   int result;
76321
76322   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_SPEED;
76323   jresult = (int)result;
76324   return jresult;
76325 }
76326
76327
76328 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_OVERSHOOT_get() {
76329   int jresult ;
76330   int result;
76331
76332   result = (int)Dali::Toolkit::ItemView::Property::OVERSHOOT;
76333   jresult = (int)result;
76334   return jresult;
76335 }
76336
76337
76338 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_DIRECTION_get() {
76339   int jresult ;
76340   int result;
76341
76342   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_DIRECTION;
76343   jresult = (int)result;
76344   return jresult;
76345 }
76346
76347
76348 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_ORIENTATION_get() {
76349   int jresult ;
76350   int result;
76351
76352   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_ORIENTATION;
76353   jresult = (int)result;
76354   return jresult;
76355 }
76356
76357
76358 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_CONTENT_SIZE_get() {
76359   int jresult ;
76360   int result;
76361
76362   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_CONTENT_SIZE;
76363   jresult = (int)result;
76364   return jresult;
76365 }
76366
76367
76368 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView_Property() {
76369   void * jresult ;
76370   Dali::Toolkit::ItemView::Property *result = 0 ;
76371
76372   {
76373     try {
76374       result = (Dali::Toolkit::ItemView::Property *)new Dali::Toolkit::ItemView::Property();
76375     } catch (std::out_of_range& e) {
76376       {
76377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76378       };
76379     } catch (std::exception& e) {
76380       {
76381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76382       };
76383     } catch (Dali::DaliException e) {
76384       {
76385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76386       };
76387     } catch (...) {
76388       {
76389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76390       };
76391     }
76392   }
76393
76394   jresult = (void *)result;
76395   return jresult;
76396 }
76397
76398
76399 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView_Property(void * jarg1) {
76400   Dali::Toolkit::ItemView::Property *arg1 = (Dali::Toolkit::ItemView::Property *) 0 ;
76401
76402   arg1 = (Dali::Toolkit::ItemView::Property *)jarg1;
76403   {
76404     try {
76405       delete arg1;
76406     } catch (std::out_of_range& e) {
76407       {
76408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76409       };
76410     } catch (std::exception& e) {
76411       {
76412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76413       };
76414     } catch (Dali::DaliException e) {
76415       {
76416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76417       };
76418     } catch (...) {
76419       {
76420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76421       };
76422     }
76423   }
76424
76425 }
76426
76427
76428 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_0() {
76429   void * jresult ;
76430   Dali::Toolkit::ItemView *result = 0 ;
76431
76432   {
76433     try {
76434       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView();
76435     } catch (std::out_of_range& e) {
76436       {
76437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76438       };
76439     } catch (std::exception& e) {
76440       {
76441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76442       };
76443     } catch (Dali::DaliException e) {
76444       {
76445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76446       };
76447     } catch (...) {
76448       {
76449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76450       };
76451     }
76452   }
76453
76454   jresult = (void *)result;
76455   return jresult;
76456 }
76457
76458
76459 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_1(void * jarg1) {
76460   void * jresult ;
76461   Dali::Toolkit::ItemView *arg1 = 0 ;
76462   Dali::Toolkit::ItemView *result = 0 ;
76463
76464   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76465   if (!arg1) {
76466     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
76467     return 0;
76468   }
76469   {
76470     try {
76471       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView((Dali::Toolkit::ItemView const &)*arg1);
76472     } catch (std::out_of_range& e) {
76473       {
76474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76475       };
76476     } catch (std::exception& e) {
76477       {
76478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76479       };
76480     } catch (Dali::DaliException e) {
76481       {
76482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76483       };
76484     } catch (...) {
76485       {
76486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76487       };
76488     }
76489   }
76490
76491   jresult = (void *)result;
76492   return jresult;
76493 }
76494
76495
76496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_Assign(void * jarg1, void * jarg2) {
76497   void * jresult ;
76498   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76499   Dali::Toolkit::ItemView *arg2 = 0 ;
76500   Dali::Toolkit::ItemView *result = 0 ;
76501
76502   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76503   arg2 = (Dali::Toolkit::ItemView *)jarg2;
76504   if (!arg2) {
76505     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
76506     return 0;
76507   }
76508   {
76509     try {
76510       result = (Dali::Toolkit::ItemView *) &(arg1)->operator =((Dali::Toolkit::ItemView const &)*arg2);
76511     } catch (std::out_of_range& e) {
76512       {
76513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76514       };
76515     } catch (std::exception& e) {
76516       {
76517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76518       };
76519     } catch (Dali::DaliException e) {
76520       {
76521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76522       };
76523     } catch (...) {
76524       {
76525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76526       };
76527     }
76528   }
76529
76530   jresult = (void *)result;
76531   return jresult;
76532 }
76533
76534
76535 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView(void * jarg1) {
76536   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76537
76538   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76539   {
76540     try {
76541       delete arg1;
76542     } catch (std::out_of_range& e) {
76543       {
76544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76545       };
76546     } catch (std::exception& e) {
76547       {
76548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76549       };
76550     } catch (Dali::DaliException e) {
76551       {
76552         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76553       };
76554     } catch (...) {
76555       {
76556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76557       };
76558     }
76559   }
76560
76561 }
76562
76563
76564 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_New(void * jarg1) {
76565   void * jresult ;
76566   Dali::Toolkit::ItemFactory *arg1 = 0 ;
76567   Dali::Toolkit::ItemView result;
76568
76569   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
76570   if (!arg1) {
76571     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemFactory & type is null", 0);
76572     return 0;
76573   }
76574   {
76575     try {
76576       result = Dali::Toolkit::ItemView::New(*arg1);
76577     } catch (std::out_of_range& e) {
76578       {
76579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76580       };
76581     } catch (std::exception& e) {
76582       {
76583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76584       };
76585     } catch (Dali::DaliException e) {
76586       {
76587         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76588       };
76589     } catch (...) {
76590       {
76591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76592       };
76593     }
76594   }
76595
76596   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
76597   return jresult;
76598 }
76599
76600
76601 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_DownCast(void * jarg1) {
76602   void * jresult ;
76603   Dali::BaseHandle arg1 ;
76604   Dali::BaseHandle *argp1 ;
76605   Dali::Toolkit::ItemView result;
76606
76607   argp1 = (Dali::BaseHandle *)jarg1;
76608   if (!argp1) {
76609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
76610     return 0;
76611   }
76612   arg1 = *argp1;
76613   {
76614     try {
76615       result = Dali::Toolkit::ItemView::DownCast(arg1);
76616     } catch (std::out_of_range& e) {
76617       {
76618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76619       };
76620     } catch (std::exception& e) {
76621       {
76622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76623       };
76624     } catch (Dali::DaliException e) {
76625       {
76626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76627       };
76628     } catch (...) {
76629       {
76630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76631       };
76632     }
76633   }
76634
76635   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
76636   return jresult;
76637 }
76638
76639
76640 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetLayoutCount(void * jarg1) {
76641   unsigned int jresult ;
76642   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76643   unsigned int result;
76644
76645   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76646   {
76647     try {
76648       result = (unsigned int)((Dali::Toolkit::ItemView const *)arg1)->GetLayoutCount();
76649     } catch (std::out_of_range& e) {
76650       {
76651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76652       };
76653     } catch (std::exception& e) {
76654       {
76655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76656       };
76657     } catch (Dali::DaliException e) {
76658       {
76659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76660       };
76661     } catch (...) {
76662       {
76663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76664       };
76665     }
76666   }
76667
76668   jresult = result;
76669   return jresult;
76670 }
76671
76672
76673 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_AddLayout(void * jarg1, void * jarg2) {
76674   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76675   Dali::Toolkit::ItemLayout *arg2 = 0 ;
76676
76677   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76678   arg2 = (Dali::Toolkit::ItemLayout *)jarg2;
76679   if (!arg2) {
76680     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemLayout & type is null", 0);
76681     return ;
76682   }
76683   {
76684     try {
76685       (arg1)->AddLayout(*arg2);
76686     } catch (std::out_of_range& e) {
76687       {
76688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76689       };
76690     } catch (std::exception& e) {
76691       {
76692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76693       };
76694     } catch (Dali::DaliException e) {
76695       {
76696         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76697       };
76698     } catch (...) {
76699       {
76700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76701       };
76702     }
76703   }
76704
76705 }
76706
76707
76708 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveLayout(void * jarg1, unsigned int jarg2) {
76709   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76710   unsigned int arg2 ;
76711
76712   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76713   arg2 = (unsigned int)jarg2;
76714   {
76715     try {
76716       (arg1)->RemoveLayout(arg2);
76717     } catch (std::out_of_range& e) {
76718       {
76719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76720       };
76721     } catch (std::exception& e) {
76722       {
76723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76724       };
76725     } catch (Dali::DaliException e) {
76726       {
76727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76728       };
76729     } catch (...) {
76730       {
76731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76732       };
76733     }
76734   }
76735
76736 }
76737
76738
76739 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetLayout(void * jarg1, unsigned int jarg2) {
76740   void * jresult ;
76741   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76742   unsigned int arg2 ;
76743   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
76744
76745   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76746   arg2 = (unsigned int)jarg2;
76747   {
76748     try {
76749       result = ((Dali::Toolkit::ItemView const *)arg1)->GetLayout(arg2);
76750     } catch (std::out_of_range& e) {
76751       {
76752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76753       };
76754     } catch (std::exception& e) {
76755       {
76756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76757       };
76758     } catch (Dali::DaliException e) {
76759       {
76760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76761       };
76762     } catch (...) {
76763       {
76764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76765       };
76766     }
76767   }
76768
76769   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
76770   return jresult;
76771 }
76772
76773
76774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetActiveLayout(void * jarg1) {
76775   void * jresult ;
76776   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76777   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
76778
76779   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76780   {
76781     try {
76782       result = ((Dali::Toolkit::ItemView const *)arg1)->GetActiveLayout();
76783     } catch (std::out_of_range& e) {
76784       {
76785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76786       };
76787     } catch (std::exception& e) {
76788       {
76789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76790       };
76791     } catch (Dali::DaliException e) {
76792       {
76793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76794       };
76795     } catch (...) {
76796       {
76797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76798       };
76799     }
76800   }
76801
76802   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
76803   return jresult;
76804 }
76805
76806
76807 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetCurrentLayoutPosition(void * jarg1, unsigned int jarg2) {
76808   float jresult ;
76809   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76810   Dali::Toolkit::ItemId arg2 ;
76811   float result;
76812
76813   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76814   arg2 = (Dali::Toolkit::ItemId)jarg2;
76815   {
76816     try {
76817       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetCurrentLayoutPosition(arg2);
76818     } catch (std::out_of_range& e) {
76819       {
76820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76821       };
76822     } catch (std::exception& e) {
76823       {
76824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76825       };
76826     } catch (Dali::DaliException e) {
76827       {
76828         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76829       };
76830     } catch (...) {
76831       {
76832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76833       };
76834     }
76835   }
76836
76837   jresult = result;
76838   return jresult;
76839 }
76840
76841
76842 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ActivateLayout(void * jarg1, unsigned int jarg2, void * jarg3, float jarg4) {
76843   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76844   unsigned int arg2 ;
76845   Dali::Vector3 arg3 ;
76846   float arg4 ;
76847   Dali::Vector3 *argp3 ;
76848
76849   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76850   arg2 = (unsigned int)jarg2;
76851   argp3 = (Dali::Vector3 *)jarg3;
76852   if (!argp3) {
76853     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
76854     return ;
76855   }
76856   arg3 = *argp3;
76857   arg4 = (float)jarg4;
76858   {
76859     try {
76860       (arg1)->ActivateLayout(arg2,arg3,arg4);
76861     } catch (std::out_of_range& e) {
76862       {
76863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76864       };
76865     } catch (std::exception& e) {
76866       {
76867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76868       };
76869     } catch (Dali::DaliException e) {
76870       {
76871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76872       };
76873     } catch (...) {
76874       {
76875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76876       };
76877     }
76878   }
76879
76880 }
76881
76882
76883 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_DeactivateCurrentLayout(void * jarg1) {
76884   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76885
76886   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76887   {
76888     try {
76889       (arg1)->DeactivateCurrentLayout();
76890     } catch (std::out_of_range& e) {
76891       {
76892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76893       };
76894     } catch (std::exception& e) {
76895       {
76896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76897       };
76898     } catch (Dali::DaliException e) {
76899       {
76900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76901       };
76902     } catch (...) {
76903       {
76904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76905       };
76906     }
76907   }
76908
76909 }
76910
76911
76912 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeSpeed(void * jarg1, float jarg2) {
76913   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76914   float arg2 ;
76915
76916   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76917   arg2 = (float)jarg2;
76918   {
76919     try {
76920       (arg1)->SetMinimumSwipeSpeed(arg2);
76921     } catch (std::out_of_range& e) {
76922       {
76923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76924       };
76925     } catch (std::exception& e) {
76926       {
76927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76928       };
76929     } catch (Dali::DaliException e) {
76930       {
76931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76932       };
76933     } catch (...) {
76934       {
76935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76936       };
76937     }
76938   }
76939
76940 }
76941
76942
76943 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeSpeed(void * jarg1) {
76944   float jresult ;
76945   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76946   float result;
76947
76948   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76949   {
76950     try {
76951       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeSpeed();
76952     } catch (std::out_of_range& e) {
76953       {
76954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76955       };
76956     } catch (std::exception& e) {
76957       {
76958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76959       };
76960     } catch (Dali::DaliException e) {
76961       {
76962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76963       };
76964     } catch (...) {
76965       {
76966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76967       };
76968     }
76969   }
76970
76971   jresult = result;
76972   return jresult;
76973 }
76974
76975
76976 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeDistance(void * jarg1, float jarg2) {
76977   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76978   float arg2 ;
76979
76980   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76981   arg2 = (float)jarg2;
76982   {
76983     try {
76984       (arg1)->SetMinimumSwipeDistance(arg2);
76985     } catch (std::out_of_range& e) {
76986       {
76987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76988       };
76989     } catch (std::exception& e) {
76990       {
76991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76992       };
76993     } catch (Dali::DaliException e) {
76994       {
76995         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76996       };
76997     } catch (...) {
76998       {
76999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77000       };
77001     }
77002   }
77003
77004 }
77005
77006
77007 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeDistance(void * jarg1) {
77008   float jresult ;
77009   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77010   float result;
77011
77012   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77013   {
77014     try {
77015       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeDistance();
77016     } catch (std::out_of_range& e) {
77017       {
77018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77019       };
77020     } catch (std::exception& e) {
77021       {
77022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77023       };
77024     } catch (Dali::DaliException e) {
77025       {
77026         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77027       };
77028     } catch (...) {
77029       {
77030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77031       };
77032     }
77033   }
77034
77035   jresult = result;
77036   return jresult;
77037 }
77038
77039
77040 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetWheelScrollDistanceStep(void * jarg1, float jarg2) {
77041   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77042   float arg2 ;
77043
77044   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77045   arg2 = (float)jarg2;
77046   {
77047     try {
77048       (arg1)->SetWheelScrollDistanceStep(arg2);
77049     } catch (std::out_of_range& e) {
77050       {
77051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77052       };
77053     } catch (std::exception& e) {
77054       {
77055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77056       };
77057     } catch (Dali::DaliException e) {
77058       {
77059         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77060       };
77061     } catch (...) {
77062       {
77063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77064       };
77065     }
77066   }
77067
77068 }
77069
77070
77071 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetWheelScrollDistanceStep(void * jarg1) {
77072   float jresult ;
77073   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77074   float result;
77075
77076   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77077   {
77078     try {
77079       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetWheelScrollDistanceStep();
77080     } catch (std::out_of_range& e) {
77081       {
77082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77083       };
77084     } catch (std::exception& e) {
77085       {
77086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77087       };
77088     } catch (Dali::DaliException e) {
77089       {
77090         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77091       };
77092     } catch (...) {
77093       {
77094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77095       };
77096     }
77097   }
77098
77099   jresult = result;
77100   return jresult;
77101 }
77102
77103
77104 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoring(void * jarg1, unsigned int jarg2) {
77105   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77106   bool arg2 ;
77107
77108   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77109   arg2 = jarg2 ? true : false;
77110   {
77111     try {
77112       (arg1)->SetAnchoring(arg2);
77113     } catch (std::out_of_range& e) {
77114       {
77115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77116       };
77117     } catch (std::exception& e) {
77118       {
77119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77120       };
77121     } catch (Dali::DaliException e) {
77122       {
77123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77124       };
77125     } catch (...) {
77126       {
77127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77128       };
77129     }
77130   }
77131
77132 }
77133
77134 //// ========================= end of part 3 =============================
77135
77136 //// ========================== start part 4 ===============================
77137
77138
77139 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoring(void * jarg1) {
77140   unsigned int jresult ;
77141   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77142   bool result;
77143
77144   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77145   {
77146     try {
77147       result = (bool)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoring();
77148     } catch (std::out_of_range& e) {
77149       {
77150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77151       };
77152     } catch (std::exception& e) {
77153       {
77154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77155       };
77156     } catch (Dali::DaliException e) {
77157       {
77158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77159       };
77160     } catch (...) {
77161       {
77162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77163       };
77164     }
77165   }
77166
77167   jresult = result;
77168   return jresult;
77169 }
77170
77171
77172 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoringDuration(void * jarg1, float jarg2) {
77173   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77174   float arg2 ;
77175
77176   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77177   arg2 = (float)jarg2;
77178   {
77179     try {
77180       (arg1)->SetAnchoringDuration(arg2);
77181     } catch (std::out_of_range& e) {
77182       {
77183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77184       };
77185     } catch (std::exception& e) {
77186       {
77187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77188       };
77189     } catch (Dali::DaliException e) {
77190       {
77191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77192       };
77193     } catch (...) {
77194       {
77195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77196       };
77197     }
77198   }
77199
77200 }
77201
77202
77203 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoringDuration(void * jarg1) {
77204   float jresult ;
77205   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77206   float result;
77207
77208   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77209   {
77210     try {
77211       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoringDuration();
77212     } catch (std::out_of_range& e) {
77213       {
77214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77215       };
77216     } catch (std::exception& e) {
77217       {
77218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77219       };
77220     } catch (Dali::DaliException e) {
77221       {
77222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77223       };
77224     } catch (...) {
77225       {
77226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77227       };
77228     }
77229   }
77230
77231   jresult = result;
77232   return jresult;
77233 }
77234
77235
77236 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ScrollToItem(void * jarg1, unsigned int jarg2, float jarg3) {
77237   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77238   Dali::Toolkit::ItemId arg2 ;
77239   float arg3 ;
77240
77241   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77242   arg2 = (Dali::Toolkit::ItemId)jarg2;
77243   arg3 = (float)jarg3;
77244   {
77245     try {
77246       (arg1)->ScrollToItem(arg2,arg3);
77247     } catch (std::out_of_range& e) {
77248       {
77249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77250       };
77251     } catch (std::exception& e) {
77252       {
77253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77254       };
77255     } catch (Dali::DaliException e) {
77256       {
77257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77258       };
77259     } catch (...) {
77260       {
77261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77262       };
77263     }
77264   }
77265
77266 }
77267
77268
77269 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetRefreshInterval(void * jarg1, float jarg2) {
77270   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77271   float arg2 ;
77272
77273   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77274   arg2 = (float)jarg2;
77275   {
77276     try {
77277       (arg1)->SetRefreshInterval(arg2);
77278     } catch (std::out_of_range& e) {
77279       {
77280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77281       };
77282     } catch (std::exception& e) {
77283       {
77284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77285       };
77286     } catch (Dali::DaliException e) {
77287       {
77288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77289       };
77290     } catch (...) {
77291       {
77292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77293       };
77294     }
77295   }
77296
77297 }
77298
77299
77300 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetRefreshInterval(void * jarg1) {
77301   float jresult ;
77302   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77303   float result;
77304
77305   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77306   {
77307     try {
77308       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetRefreshInterval();
77309     } catch (std::out_of_range& e) {
77310       {
77311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77312       };
77313     } catch (std::exception& e) {
77314       {
77315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77316       };
77317     } catch (Dali::DaliException e) {
77318       {
77319         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77320       };
77321     } catch (...) {
77322       {
77323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77324       };
77325     }
77326   }
77327
77328   jresult = result;
77329   return jresult;
77330 }
77331
77332
77333 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_Refresh(void * jarg1) {
77334   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77335
77336   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77337   {
77338     try {
77339       (arg1)->Refresh();
77340     } catch (std::out_of_range& e) {
77341       {
77342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77343       };
77344     } catch (std::exception& e) {
77345       {
77346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77347       };
77348     } catch (Dali::DaliException e) {
77349       {
77350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77351       };
77352     } catch (...) {
77353       {
77354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77355       };
77356     }
77357   }
77358
77359 }
77360
77361
77362 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItem(void * jarg1, unsigned int jarg2) {
77363   void * jresult ;
77364   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77365   Dali::Toolkit::ItemId arg2 ;
77366   Dali::Actor result;
77367
77368   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77369   arg2 = (Dali::Toolkit::ItemId)jarg2;
77370   {
77371     try {
77372       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItem(arg2);
77373     } catch (std::out_of_range& e) {
77374       {
77375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77376       };
77377     } catch (std::exception& e) {
77378       {
77379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77380       };
77381     } catch (Dali::DaliException e) {
77382       {
77383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77384       };
77385     } catch (...) {
77386       {
77387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77388       };
77389     }
77390   }
77391
77392   jresult = new Dali::Actor((const Dali::Actor &)result);
77393   return jresult;
77394 }
77395
77396
77397 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetItemId(void * jarg1, void * jarg2) {
77398   unsigned int jresult ;
77399   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77400   Dali::Actor arg2 ;
77401   Dali::Actor *argp2 ;
77402   Dali::Toolkit::ItemId result;
77403
77404   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77405   argp2 = (Dali::Actor *)jarg2;
77406   if (!argp2) {
77407     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
77408     return 0;
77409   }
77410   arg2 = *argp2;
77411   {
77412     try {
77413       result = (Dali::Toolkit::ItemId)((Dali::Toolkit::ItemView const *)arg1)->GetItemId(arg2);
77414     } catch (std::out_of_range& e) {
77415       {
77416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77417       };
77418     } catch (std::exception& e) {
77419       {
77420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77421       };
77422     } catch (Dali::DaliException e) {
77423       {
77424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77425       };
77426     } catch (...) {
77427       {
77428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77429       };
77430     }
77431   }
77432
77433   jresult = result;
77434   return jresult;
77435 }
77436
77437
77438 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItem(void * jarg1, void * jarg2, float jarg3) {
77439   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77440   Dali::Toolkit::Item arg2 ;
77441   float arg3 ;
77442   Dali::Toolkit::Item *argp2 ;
77443
77444   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77445   argp2 = (Dali::Toolkit::Item *)jarg2;
77446   if (!argp2) {
77447     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
77448     return ;
77449   }
77450   arg2 = *argp2;
77451   arg3 = (float)jarg3;
77452   {
77453     try {
77454       (arg1)->InsertItem(arg2,arg3);
77455     } catch (std::out_of_range& e) {
77456       {
77457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77458       };
77459     } catch (std::exception& e) {
77460       {
77461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77462       };
77463     } catch (Dali::DaliException e) {
77464       {
77465         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77466       };
77467     } catch (...) {
77468       {
77469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77470       };
77471     }
77472   }
77473
77474 }
77475
77476
77477 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItems(void * jarg1, void * jarg2, float jarg3) {
77478   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77479   Dali::Toolkit::ItemContainer *arg2 = 0 ;
77480   float arg3 ;
77481
77482   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77483   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
77484   if (!arg2) {
77485     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
77486     return ;
77487   }
77488   arg3 = (float)jarg3;
77489   {
77490     try {
77491       (arg1)->InsertItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
77492     } catch (std::out_of_range& e) {
77493       {
77494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77495       };
77496     } catch (std::exception& e) {
77497       {
77498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77499       };
77500     } catch (Dali::DaliException e) {
77501       {
77502         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77503       };
77504     } catch (...) {
77505       {
77506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77507       };
77508     }
77509   }
77510
77511 }
77512
77513
77514 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItem(void * jarg1, unsigned int jarg2, float jarg3) {
77515   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77516   Dali::Toolkit::ItemId arg2 ;
77517   float arg3 ;
77518
77519   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77520   arg2 = (Dali::Toolkit::ItemId)jarg2;
77521   arg3 = (float)jarg3;
77522   {
77523     try {
77524       (arg1)->RemoveItem(arg2,arg3);
77525     } catch (std::out_of_range& e) {
77526       {
77527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77528       };
77529     } catch (std::exception& e) {
77530       {
77531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77532       };
77533     } catch (Dali::DaliException e) {
77534       {
77535         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77536       };
77537     } catch (...) {
77538       {
77539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77540       };
77541     }
77542   }
77543
77544 }
77545
77546
77547 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItems(void * jarg1, void * jarg2, float jarg3) {
77548   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77549   Dali::Toolkit::ItemIdContainer *arg2 = 0 ;
77550   float arg3 ;
77551
77552   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77553   arg2 = (Dali::Toolkit::ItemIdContainer *)jarg2;
77554   if (!arg2) {
77555     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemIdContainer const & type is null", 0);
77556     return ;
77557   }
77558   arg3 = (float)jarg3;
77559   {
77560     try {
77561       (arg1)->RemoveItems((Dali::Toolkit::ItemIdContainer const &)*arg2,arg3);
77562     } catch (std::out_of_range& e) {
77563       {
77564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77565       };
77566     } catch (std::exception& e) {
77567       {
77568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77569       };
77570     } catch (Dali::DaliException e) {
77571       {
77572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77573       };
77574     } catch (...) {
77575       {
77576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77577       };
77578     }
77579   }
77580
77581 }
77582
77583
77584 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItem(void * jarg1, void * jarg2, float jarg3) {
77585   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77586   Dali::Toolkit::Item arg2 ;
77587   float arg3 ;
77588   Dali::Toolkit::Item *argp2 ;
77589
77590   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77591   argp2 = (Dali::Toolkit::Item *)jarg2;
77592   if (!argp2) {
77593     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
77594     return ;
77595   }
77596   arg2 = *argp2;
77597   arg3 = (float)jarg3;
77598   {
77599     try {
77600       (arg1)->ReplaceItem(arg2,arg3);
77601     } catch (std::out_of_range& e) {
77602       {
77603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77604       };
77605     } catch (std::exception& e) {
77606       {
77607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77608       };
77609     } catch (Dali::DaliException e) {
77610       {
77611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77612       };
77613     } catch (...) {
77614       {
77615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77616       };
77617     }
77618   }
77619
77620 }
77621
77622
77623 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItems(void * jarg1, void * jarg2, float jarg3) {
77624   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77625   Dali::Toolkit::ItemContainer *arg2 = 0 ;
77626   float arg3 ;
77627
77628   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77629   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
77630   if (!arg2) {
77631     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
77632     return ;
77633   }
77634   arg3 = (float)jarg3;
77635   {
77636     try {
77637       (arg1)->ReplaceItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
77638     } catch (std::out_of_range& e) {
77639       {
77640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77641       };
77642     } catch (std::exception& e) {
77643       {
77644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77645       };
77646     } catch (Dali::DaliException e) {
77647       {
77648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77649       };
77650     } catch (...) {
77651       {
77652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77653       };
77654     }
77655   }
77656
77657 }
77658
77659
77660 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsParentOrigin(void * jarg1, void * jarg2) {
77661   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77662   Dali::Vector3 *arg2 = 0 ;
77663
77664   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77665   arg2 = (Dali::Vector3 *)jarg2;
77666   if (!arg2) {
77667     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
77668     return ;
77669   }
77670   {
77671     try {
77672       (arg1)->SetItemsParentOrigin((Dali::Vector3 const &)*arg2);
77673     } catch (std::out_of_range& e) {
77674       {
77675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77676       };
77677     } catch (std::exception& e) {
77678       {
77679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77680       };
77681     } catch (Dali::DaliException e) {
77682       {
77683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77684       };
77685     } catch (...) {
77686       {
77687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77688       };
77689     }
77690   }
77691
77692 }
77693
77694
77695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsParentOrigin(void * jarg1) {
77696   void * jresult ;
77697   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77698   Dali::Vector3 result;
77699
77700   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77701   {
77702     try {
77703       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsParentOrigin();
77704     } catch (std::out_of_range& e) {
77705       {
77706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77707       };
77708     } catch (std::exception& e) {
77709       {
77710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77711       };
77712     } catch (Dali::DaliException e) {
77713       {
77714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77715       };
77716     } catch (...) {
77717       {
77718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77719       };
77720     }
77721   }
77722
77723   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
77724   return jresult;
77725 }
77726
77727
77728 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsAnchorPoint(void * jarg1, void * jarg2) {
77729   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77730   Dali::Vector3 *arg2 = 0 ;
77731
77732   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77733   arg2 = (Dali::Vector3 *)jarg2;
77734   if (!arg2) {
77735     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
77736     return ;
77737   }
77738   {
77739     try {
77740       (arg1)->SetItemsAnchorPoint((Dali::Vector3 const &)*arg2);
77741     } catch (std::out_of_range& e) {
77742       {
77743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77744       };
77745     } catch (std::exception& e) {
77746       {
77747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77748       };
77749     } catch (Dali::DaliException e) {
77750       {
77751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77752       };
77753     } catch (...) {
77754       {
77755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77756       };
77757     }
77758   }
77759
77760 }
77761
77762
77763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsAnchorPoint(void * jarg1) {
77764   void * jresult ;
77765   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77766   Dali::Vector3 result;
77767
77768   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77769   {
77770     try {
77771       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsAnchorPoint();
77772     } catch (std::out_of_range& e) {
77773       {
77774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77775       };
77776     } catch (std::exception& e) {
77777       {
77778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77779       };
77780     } catch (Dali::DaliException e) {
77781       {
77782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77783       };
77784     } catch (...) {
77785       {
77786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77787       };
77788     }
77789   }
77790
77791   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
77792   return jresult;
77793 }
77794
77795
77796 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_GetItemsRange(void * jarg1, void * jarg2) {
77797   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77798   Dali::Toolkit::ItemRange *arg2 = 0 ;
77799
77800   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77801   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
77802   if (!arg2) {
77803     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange & type is null", 0);
77804     return ;
77805   }
77806   {
77807     try {
77808       (arg1)->GetItemsRange(*arg2);
77809     } catch (std::out_of_range& e) {
77810       {
77811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77812       };
77813     } catch (std::exception& e) {
77814       {
77815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77816       };
77817     } catch (Dali::DaliException e) {
77818       {
77819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77820       };
77821     } catch (...) {
77822       {
77823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77824       };
77825     }
77826   }
77827
77828 }
77829
77830
77831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_LayoutActivatedSignal(void * jarg1) {
77832   void * jresult ;
77833   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77834   Dali::Toolkit::ItemView::LayoutActivatedSignalType *result = 0 ;
77835
77836   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77837   {
77838     try {
77839       result = (Dali::Toolkit::ItemView::LayoutActivatedSignalType *) &(arg1)->LayoutActivatedSignal();
77840     } catch (std::out_of_range& e) {
77841       {
77842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77843       };
77844     } catch (std::exception& e) {
77845       {
77846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77847       };
77848     } catch (Dali::DaliException e) {
77849       {
77850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77851       };
77852     } catch (...) {
77853       {
77854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77855       };
77856     }
77857   }
77858
77859   jresult = (void *)result;
77860   return jresult;
77861 }
77862
77863
77864 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MoveActorConstraint(void * jarg1, void * jarg2) {
77865   Dali::Vector3 *arg1 = 0 ;
77866   PropertyInputContainer *arg2 = 0 ;
77867
77868   arg1 = (Dali::Vector3 *)jarg1;
77869   if (!arg1) {
77870     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
77871     return ;
77872   }
77873   arg2 = (PropertyInputContainer *)jarg2;
77874   if (!arg2) {
77875     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
77876     return ;
77877   }
77878   {
77879     try {
77880       Dali::Toolkit::MoveActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
77881     } catch (std::out_of_range& e) {
77882       {
77883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77884       };
77885     } catch (std::exception& e) {
77886       {
77887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77888       };
77889     } catch (Dali::DaliException e) {
77890       {
77891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77892       };
77893     } catch (...) {
77894       {
77895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77896       };
77897     }
77898   }
77899
77900 }
77901
77902
77903 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WrapActorConstraint(void * jarg1, void * jarg2) {
77904   Dali::Vector3 *arg1 = 0 ;
77905   PropertyInputContainer *arg2 = 0 ;
77906
77907   arg1 = (Dali::Vector3 *)jarg1;
77908   if (!arg1) {
77909     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
77910     return ;
77911   }
77912   arg2 = (PropertyInputContainer *)jarg2;
77913   if (!arg2) {
77914     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
77915     return ;
77916   }
77917   {
77918     try {
77919       Dali::Toolkit::WrapActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
77920     } catch (std::out_of_range& e) {
77921       {
77922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77923       };
77924     } catch (std::exception& e) {
77925       {
77926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77927       };
77928     } catch (Dali::DaliException e) {
77929       {
77930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77931       };
77932     } catch (...) {
77933       {
77934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77935       };
77936     }
77937   }
77938
77939 }
77940
77941
77942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewEffect() {
77943   void * jresult ;
77944   Dali::Toolkit::ScrollViewEffect *result = 0 ;
77945
77946   {
77947     try {
77948       result = (Dali::Toolkit::ScrollViewEffect *)new Dali::Toolkit::ScrollViewEffect();
77949     } catch (std::out_of_range& e) {
77950       {
77951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77952       };
77953     } catch (std::exception& e) {
77954       {
77955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77956       };
77957     } catch (Dali::DaliException e) {
77958       {
77959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77960       };
77961     } catch (...) {
77962       {
77963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77964       };
77965     }
77966   }
77967
77968   jresult = (void *)result;
77969   return jresult;
77970 }
77971
77972
77973 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewEffect(void * jarg1) {
77974   Dali::Toolkit::ScrollViewEffect *arg1 = (Dali::Toolkit::ScrollViewEffect *) 0 ;
77975
77976   arg1 = (Dali::Toolkit::ScrollViewEffect *)jarg1;
77977   {
77978     try {
77979       delete arg1;
77980     } catch (std::out_of_range& e) {
77981       {
77982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77983       };
77984     } catch (std::exception& e) {
77985       {
77986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77987       };
77988     } catch (Dali::DaliException e) {
77989       {
77990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77991       };
77992     } catch (...) {
77993       {
77994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77995       };
77996     }
77997   }
77998
77999 }
78000
78001
78002 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_New(void * jarg1, void * jarg2, int jarg3, void * jarg4, unsigned int jarg5) {
78003   void * jresult ;
78004   Dali::Path arg1 ;
78005   Dali::Vector3 *arg2 = 0 ;
78006   Dali::Property::Index arg3 ;
78007   Dali::Vector3 *arg4 = 0 ;
78008   unsigned int arg5 ;
78009   Dali::Path *argp1 ;
78010   Dali::Toolkit::ScrollViewPagePathEffect result;
78011
78012   argp1 = (Dali::Path *)jarg1;
78013   if (!argp1) {
78014     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
78015     return 0;
78016   }
78017   arg1 = *argp1;
78018   arg2 = (Dali::Vector3 *)jarg2;
78019   if (!arg2) {
78020     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
78021     return 0;
78022   }
78023   arg3 = (Dali::Property::Index)jarg3;
78024   arg4 = (Dali::Vector3 *)jarg4;
78025   if (!arg4) {
78026     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
78027     return 0;
78028   }
78029   arg5 = (unsigned int)jarg5;
78030   {
78031     try {
78032       result = Dali::Toolkit::ScrollViewPagePathEffect::New(arg1,(Dali::Vector3 const &)*arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
78033     } catch (std::out_of_range& e) {
78034       {
78035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78036       };
78037     } catch (std::exception& e) {
78038       {
78039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78040       };
78041     } catch (Dali::DaliException e) {
78042       {
78043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78044       };
78045     } catch (...) {
78046       {
78047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78048       };
78049     }
78050   }
78051
78052   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
78053   return jresult;
78054 }
78055
78056
78057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewPagePathEffect() {
78058   void * jresult ;
78059   Dali::Toolkit::ScrollViewPagePathEffect *result = 0 ;
78060
78061   {
78062     try {
78063       result = (Dali::Toolkit::ScrollViewPagePathEffect *)new Dali::Toolkit::ScrollViewPagePathEffect();
78064     } catch (std::out_of_range& e) {
78065       {
78066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78067       };
78068     } catch (std::exception& e) {
78069       {
78070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78071       };
78072     } catch (Dali::DaliException e) {
78073       {
78074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78075       };
78076     } catch (...) {
78077       {
78078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78079       };
78080     }
78081   }
78082
78083   jresult = (void *)result;
78084   return jresult;
78085 }
78086
78087
78088 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_DownCast(void * jarg1) {
78089   void * jresult ;
78090   Dali::BaseHandle arg1 ;
78091   Dali::BaseHandle *argp1 ;
78092   Dali::Toolkit::ScrollViewPagePathEffect result;
78093
78094   argp1 = (Dali::BaseHandle *)jarg1;
78095   if (!argp1) {
78096     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
78097     return 0;
78098   }
78099   arg1 = *argp1;
78100   {
78101     try {
78102       result = Dali::Toolkit::ScrollViewPagePathEffect::DownCast(arg1);
78103     } catch (std::out_of_range& e) {
78104       {
78105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78106       };
78107     } catch (std::exception& e) {
78108       {
78109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78110       };
78111     } catch (Dali::DaliException e) {
78112       {
78113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78114       };
78115     } catch (...) {
78116       {
78117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78118       };
78119     }
78120   }
78121
78122   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
78123   return jresult;
78124 }
78125
78126
78127 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_ApplyToPage(void * jarg1, void * jarg2, unsigned int jarg3) {
78128   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
78129   Dali::Actor arg2 ;
78130   unsigned int arg3 ;
78131   Dali::Actor *argp2 ;
78132
78133   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
78134   argp2 = (Dali::Actor *)jarg2;
78135   if (!argp2) {
78136     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
78137     return ;
78138   }
78139   arg2 = *argp2;
78140   arg3 = (unsigned int)jarg3;
78141   {
78142     try {
78143       (arg1)->ApplyToPage(arg2,arg3);
78144     } catch (std::out_of_range& e) {
78145       {
78146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78147       };
78148     } catch (std::exception& e) {
78149       {
78150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78151       };
78152     } catch (Dali::DaliException e) {
78153       {
78154         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78155       };
78156     } catch (...) {
78157       {
78158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78159       };
78160     }
78161   }
78162
78163 }
78164
78165
78166 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewPagePathEffect(void * jarg1) {
78167   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
78168
78169   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
78170   {
78171     try {
78172       delete arg1;
78173     } catch (std::out_of_range& e) {
78174       {
78175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78176       };
78177     } catch (std::exception& e) {
78178       {
78179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78180       };
78181     } catch (Dali::DaliException e) {
78182       {
78183         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78184       };
78185     } catch (...) {
78186       {
78187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78188       };
78189     }
78190   }
78191
78192 }
78193
78194
78195 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_x_set(void * jarg1, int jarg2) {
78196   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
78197   Dali::Toolkit::ClampState arg2 ;
78198
78199   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
78200   arg2 = (Dali::Toolkit::ClampState)jarg2;
78201   if (arg1) (arg1)->x = arg2;
78202 }
78203
78204
78205 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_x_get(void * jarg1) {
78206   int jresult ;
78207   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
78208   Dali::Toolkit::ClampState result;
78209
78210   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
78211   result = (Dali::Toolkit::ClampState) ((arg1)->x);
78212   jresult = (int)result;
78213   return jresult;
78214 }
78215
78216
78217 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_y_set(void * jarg1, int jarg2) {
78218   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
78219   Dali::Toolkit::ClampState arg2 ;
78220
78221   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
78222   arg2 = (Dali::Toolkit::ClampState)jarg2;
78223   if (arg1) (arg1)->y = arg2;
78224 }
78225
78226
78227 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_y_get(void * jarg1) {
78228   int jresult ;
78229   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
78230   Dali::Toolkit::ClampState result;
78231
78232   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
78233   result = (Dali::Toolkit::ClampState) ((arg1)->y);
78234   jresult = (int)result;
78235   return jresult;
78236 }
78237
78238
78239 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ClampState2D() {
78240   void * jresult ;
78241   Dali::Toolkit::ClampState2D *result = 0 ;
78242
78243   {
78244     try {
78245       result = (Dali::Toolkit::ClampState2D *)new Dali::Toolkit::ClampState2D();
78246     } catch (std::out_of_range& e) {
78247       {
78248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78249       };
78250     } catch (std::exception& e) {
78251       {
78252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78253       };
78254     } catch (Dali::DaliException e) {
78255       {
78256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78257       };
78258     } catch (...) {
78259       {
78260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78261       };
78262     }
78263   }
78264
78265   jresult = (void *)result;
78266   return jresult;
78267 }
78268
78269
78270 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ClampState2D(void * jarg1) {
78271   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
78272
78273   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
78274   {
78275     try {
78276       delete arg1;
78277     } catch (std::out_of_range& e) {
78278       {
78279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78280       };
78281     } catch (std::exception& e) {
78282       {
78283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78284       };
78285     } catch (Dali::DaliException e) {
78286       {
78287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78288       };
78289     } catch (...) {
78290       {
78291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78292       };
78293     }
78294   }
78295
78296 }
78297
78298
78299 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_0(float jarg1, float jarg2, unsigned int jarg3) {
78300   void * jresult ;
78301   float arg1 ;
78302   float arg2 ;
78303   bool arg3 ;
78304   Dali::Toolkit::RulerDomain *result = 0 ;
78305
78306   arg1 = (float)jarg1;
78307   arg2 = (float)jarg2;
78308   arg3 = jarg3 ? true : false;
78309   {
78310     try {
78311       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2,arg3);
78312     } catch (std::out_of_range& e) {
78313       {
78314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78315       };
78316     } catch (std::exception& e) {
78317       {
78318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78319       };
78320     } catch (Dali::DaliException e) {
78321       {
78322         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78323       };
78324     } catch (...) {
78325       {
78326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78327       };
78328     }
78329   }
78330
78331   jresult = (void *)result;
78332   return jresult;
78333 }
78334
78335
78336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_1(float jarg1, float jarg2) {
78337   void * jresult ;
78338   float arg1 ;
78339   float arg2 ;
78340   Dali::Toolkit::RulerDomain *result = 0 ;
78341
78342   arg1 = (float)jarg1;
78343   arg2 = (float)jarg2;
78344   {
78345     try {
78346       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2);
78347     } catch (std::out_of_range& e) {
78348       {
78349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78350       };
78351     } catch (std::exception& e) {
78352       {
78353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78354       };
78355     } catch (Dali::DaliException e) {
78356       {
78357         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78358       };
78359     } catch (...) {
78360       {
78361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78362       };
78363     }
78364   }
78365
78366   jresult = (void *)result;
78367   return jresult;
78368 }
78369
78370
78371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_min_set(void * jarg1, float jarg2) {
78372   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78373   float arg2 ;
78374
78375   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78376   arg2 = (float)jarg2;
78377   if (arg1) (arg1)->min = arg2;
78378 }
78379
78380
78381 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_min_get(void * jarg1) {
78382   float jresult ;
78383   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78384   float result;
78385
78386   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78387   result = (float) ((arg1)->min);
78388   jresult = result;
78389   return jresult;
78390 }
78391
78392
78393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_max_set(void * jarg1, float jarg2) {
78394   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78395   float arg2 ;
78396
78397   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78398   arg2 = (float)jarg2;
78399   if (arg1) (arg1)->max = arg2;
78400 }
78401
78402
78403 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_max_get(void * jarg1) {
78404   float jresult ;
78405   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78406   float result;
78407
78408   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78409   result = (float) ((arg1)->max);
78410   jresult = result;
78411   return jresult;
78412 }
78413
78414
78415 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_set(void * jarg1, unsigned int jarg2) {
78416   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78417   bool arg2 ;
78418
78419   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78420   arg2 = jarg2 ? true : false;
78421   if (arg1) (arg1)->enabled = arg2;
78422 }
78423
78424
78425 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_get(void * jarg1) {
78426   unsigned int jresult ;
78427   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78428   bool result;
78429
78430   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78431   result = (bool) ((arg1)->enabled);
78432   jresult = result;
78433   return jresult;
78434 }
78435
78436
78437 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
78438   float jresult ;
78439   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78440   float arg2 ;
78441   float arg3 ;
78442   float arg4 ;
78443   float result;
78444
78445   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78446   arg2 = (float)jarg2;
78447   arg3 = (float)jarg3;
78448   arg4 = (float)jarg4;
78449   {
78450     try {
78451       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4);
78452     } catch (std::out_of_range& e) {
78453       {
78454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78455       };
78456     } catch (std::exception& e) {
78457       {
78458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78459       };
78460     } catch (Dali::DaliException e) {
78461       {
78462         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78463       };
78464     } catch (...) {
78465       {
78466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78467       };
78468     }
78469   }
78470
78471   jresult = result;
78472   return jresult;
78473 }
78474
78475
78476 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
78477   float jresult ;
78478   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78479   float arg2 ;
78480   float arg3 ;
78481   float result;
78482
78483   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78484   arg2 = (float)jarg2;
78485   arg3 = (float)jarg3;
78486   {
78487     try {
78488       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3);
78489     } catch (std::out_of_range& e) {
78490       {
78491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78492       };
78493     } catch (std::exception& e) {
78494       {
78495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78496       };
78497     } catch (Dali::DaliException e) {
78498       {
78499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78500       };
78501     } catch (...) {
78502       {
78503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78504       };
78505     }
78506   }
78507
78508   jresult = result;
78509   return jresult;
78510 }
78511
78512
78513 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_2(void * jarg1, float jarg2) {
78514   float jresult ;
78515   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78516   float arg2 ;
78517   float result;
78518
78519   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78520   arg2 = (float)jarg2;
78521   {
78522     try {
78523       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2);
78524     } catch (std::out_of_range& e) {
78525       {
78526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78527       };
78528     } catch (std::exception& e) {
78529       {
78530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78531       };
78532     } catch (Dali::DaliException e) {
78533       {
78534         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78535       };
78536     } catch (...) {
78537       {
78538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78539       };
78540     }
78541   }
78542
78543   jresult = result;
78544   return jresult;
78545 }
78546
78547
78548 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
78549   float jresult ;
78550   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78551   float arg2 ;
78552   float arg3 ;
78553   float arg4 ;
78554   Dali::Toolkit::ClampState *arg5 = 0 ;
78555   float result;
78556
78557   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78558   arg2 = (float)jarg2;
78559   arg3 = (float)jarg3;
78560   arg4 = (float)jarg4;
78561   arg5 = (Dali::Toolkit::ClampState *)jarg5;
78562   if (!arg5) {
78563     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
78564     return 0;
78565   }
78566   {
78567     try {
78568       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
78569     } catch (std::out_of_range& e) {
78570       {
78571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78572       };
78573     } catch (std::exception& e) {
78574       {
78575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78576       };
78577     } catch (Dali::DaliException e) {
78578       {
78579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78580       };
78581     } catch (...) {
78582       {
78583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78584       };
78585     }
78586   }
78587
78588   jresult = result;
78589   return jresult;
78590 }
78591
78592
78593 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_GetSize(void * jarg1) {
78594   float jresult ;
78595   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78596   float result;
78597
78598   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78599   {
78600     try {
78601       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->GetSize();
78602     } catch (std::out_of_range& e) {
78603       {
78604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78605       };
78606     } catch (std::exception& e) {
78607       {
78608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78609       };
78610     } catch (Dali::DaliException e) {
78611       {
78612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78613       };
78614     } catch (...) {
78615       {
78616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78617       };
78618     }
78619   }
78620
78621   jresult = result;
78622   return jresult;
78623 }
78624
78625
78626 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerDomain(void * jarg1) {
78627   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78628
78629   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78630   {
78631     try {
78632       delete arg1;
78633     } catch (std::out_of_range& e) {
78634       {
78635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78636       };
78637     } catch (std::exception& e) {
78638       {
78639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78640       };
78641     } catch (Dali::DaliException e) {
78642       {
78643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78644       };
78645     } catch (...) {
78646       {
78647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78648       };
78649     }
78650   }
78651
78652 }
78653
78654
78655 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
78656   float jresult ;
78657   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78658   float arg2 ;
78659   float arg3 ;
78660   float result;
78661
78662   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78663   arg2 = (float)jarg2;
78664   arg3 = (float)jarg3;
78665   {
78666     try {
78667       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2,arg3);
78668     } catch (std::out_of_range& e) {
78669       {
78670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78671       };
78672     } catch (std::exception& e) {
78673       {
78674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78675       };
78676     } catch (Dali::DaliException e) {
78677       {
78678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78679       };
78680     } catch (...) {
78681       {
78682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78683       };
78684     }
78685   }
78686
78687   jresult = result;
78688   return jresult;
78689 }
78690
78691
78692 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_1(void * jarg1, float jarg2) {
78693   float jresult ;
78694   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78695   float arg2 ;
78696   float result;
78697
78698   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78699   arg2 = (float)jarg2;
78700   {
78701     try {
78702       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2);
78703     } catch (std::out_of_range& e) {
78704       {
78705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78706       };
78707     } catch (std::exception& e) {
78708       {
78709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78710       };
78711     } catch (Dali::DaliException e) {
78712       {
78713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78714       };
78715     } catch (...) {
78716       {
78717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78718       };
78719     }
78720   }
78721
78722   jresult = result;
78723   return jresult;
78724 }
78725
78726
78727 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
78728   float jresult ;
78729   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78730   unsigned int arg2 ;
78731   unsigned int *arg3 = 0 ;
78732   bool arg4 ;
78733   float result;
78734
78735   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78736   arg2 = (unsigned int)jarg2;
78737   arg3 = (unsigned int *)jarg3;
78738   arg4 = jarg4 ? true : false;
78739   {
78740     try {
78741       result = (float)((Dali::Toolkit::Ruler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
78742     } catch (std::out_of_range& e) {
78743       {
78744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78745       };
78746     } catch (std::exception& e) {
78747       {
78748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78749       };
78750     } catch (Dali::DaliException e) {
78751       {
78752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78753       };
78754     } catch (...) {
78755       {
78756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78757       };
78758     }
78759   }
78760
78761   jresult = result;
78762   return jresult;
78763 }
78764
78765
78766 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
78767   unsigned int jresult ;
78768   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78769   float arg2 ;
78770   bool arg3 ;
78771   unsigned int result;
78772
78773   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78774   arg2 = (float)jarg2;
78775   arg3 = jarg3 ? true : false;
78776   {
78777     try {
78778       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetPageFromPosition(arg2,arg3);
78779     } catch (std::out_of_range& e) {
78780       {
78781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78782       };
78783     } catch (std::exception& e) {
78784       {
78785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78786       };
78787     } catch (Dali::DaliException e) {
78788       {
78789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78790       };
78791     } catch (...) {
78792       {
78793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78794       };
78795     }
78796   }
78797
78798   jresult = result;
78799   return jresult;
78800 }
78801
78802
78803 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetTotalPages(void * jarg1) {
78804   unsigned int jresult ;
78805   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78806   unsigned int result;
78807
78808   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78809   {
78810     try {
78811       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetTotalPages();
78812     } catch (std::out_of_range& e) {
78813       {
78814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78815       };
78816     } catch (std::exception& e) {
78817       {
78818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78819       };
78820     } catch (Dali::DaliException e) {
78821       {
78822         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78823       };
78824     } catch (...) {
78825       {
78826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78827       };
78828     }
78829   }
78830
78831   jresult = result;
78832   return jresult;
78833 }
78834
78835
78836 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Ruler_GetType(void * jarg1) {
78837   int jresult ;
78838   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78839   Dali::Toolkit::Ruler::RulerType result;
78840
78841   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78842   {
78843     try {
78844       result = (Dali::Toolkit::Ruler::RulerType)((Dali::Toolkit::Ruler const *)arg1)->GetType();
78845     } catch (std::out_of_range& e) {
78846       {
78847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78848       };
78849     } catch (std::exception& e) {
78850       {
78851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78852       };
78853     } catch (Dali::DaliException e) {
78854       {
78855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78856       };
78857     } catch (...) {
78858       {
78859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78860       };
78861     }
78862   }
78863
78864   jresult = (int)result;
78865   return jresult;
78866 }
78867
78868
78869 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_IsEnabled(void * jarg1) {
78870   unsigned int jresult ;
78871   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78872   bool result;
78873
78874   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78875   {
78876     try {
78877       result = (bool)((Dali::Toolkit::Ruler const *)arg1)->IsEnabled();
78878     } catch (std::out_of_range& e) {
78879       {
78880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78881       };
78882     } catch (std::exception& e) {
78883       {
78884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78885       };
78886     } catch (Dali::DaliException e) {
78887       {
78888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78889       };
78890     } catch (...) {
78891       {
78892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78893       };
78894     }
78895   }
78896
78897   jresult = result;
78898   return jresult;
78899 }
78900
78901
78902 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Enable(void * jarg1) {
78903   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78904
78905   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78906   {
78907     try {
78908       (arg1)->Enable();
78909     } catch (std::out_of_range& e) {
78910       {
78911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78912       };
78913     } catch (std::exception& e) {
78914       {
78915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78916       };
78917     } catch (Dali::DaliException e) {
78918       {
78919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78920       };
78921     } catch (...) {
78922       {
78923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78924       };
78925     }
78926   }
78927
78928 }
78929
78930
78931 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Disable(void * jarg1) {
78932   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78933
78934   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78935   {
78936     try {
78937       (arg1)->Disable();
78938     } catch (std::out_of_range& e) {
78939       {
78940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78941       };
78942     } catch (std::exception& e) {
78943       {
78944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78945       };
78946     } catch (Dali::DaliException e) {
78947       {
78948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78949       };
78950     } catch (...) {
78951       {
78952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78953       };
78954     }
78955   }
78956
78957 }
78958
78959
78960 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_SetDomain(void * jarg1, void * jarg2) {
78961   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78962   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
78963   Dali::Toolkit::RulerDomain *argp2 ;
78964
78965   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78966   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
78967   if (!argp2) {
78968     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
78969     return ;
78970   }
78971   arg2 = *argp2;
78972   {
78973     try {
78974       (arg1)->SetDomain(arg2);
78975     } catch (std::out_of_range& e) {
78976       {
78977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78978       };
78979     } catch (std::exception& e) {
78980       {
78981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78982       };
78983     } catch (Dali::DaliException e) {
78984       {
78985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78986       };
78987     } catch (...) {
78988       {
78989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78990       };
78991     }
78992   }
78993
78994 }
78995
78996
78997 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Ruler_GetDomain(void * jarg1) {
78998   void * jresult ;
78999   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
79000   Dali::Toolkit::RulerDomain *result = 0 ;
79001
79002   arg1 = (Dali::Toolkit::Ruler *)jarg1;
79003   {
79004     try {
79005       result = (Dali::Toolkit::RulerDomain *) &((Dali::Toolkit::Ruler const *)arg1)->GetDomain();
79006     } catch (std::out_of_range& e) {
79007       {
79008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79009       };
79010     } catch (std::exception& e) {
79011       {
79012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79013       };
79014     } catch (Dali::DaliException e) {
79015       {
79016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79017       };
79018     } catch (...) {
79019       {
79020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79021       };
79022     }
79023   }
79024
79025   jresult = (void *)result;
79026   return jresult;
79027 }
79028
79029
79030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_DisableDomain(void * jarg1) {
79031   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
79032
79033   arg1 = (Dali::Toolkit::Ruler *)jarg1;
79034   {
79035     try {
79036       (arg1)->DisableDomain();
79037     } catch (std::out_of_range& e) {
79038       {
79039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79040       };
79041     } catch (std::exception& e) {
79042       {
79043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79044       };
79045     } catch (Dali::DaliException e) {
79046       {
79047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79048       };
79049     } catch (...) {
79050       {
79051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79052       };
79053     }
79054   }
79055
79056 }
79057
79058
79059 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
79060   float jresult ;
79061   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
79062   float arg2 ;
79063   float arg3 ;
79064   float arg4 ;
79065   float result;
79066
79067   arg1 = (Dali::Toolkit::Ruler *)jarg1;
79068   arg2 = (float)jarg2;
79069   arg3 = (float)jarg3;
79070   arg4 = (float)jarg4;
79071   {
79072     try {
79073       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4);
79074     } catch (std::out_of_range& e) {
79075       {
79076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79077       };
79078     } catch (std::exception& e) {
79079       {
79080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79081       };
79082     } catch (Dali::DaliException e) {
79083       {
79084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79085       };
79086     } catch (...) {
79087       {
79088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79089       };
79090     }
79091   }
79092
79093   jresult = result;
79094   return jresult;
79095 }
79096
79097
79098 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
79099   float jresult ;
79100   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
79101   float arg2 ;
79102   float arg3 ;
79103   float result;
79104
79105   arg1 = (Dali::Toolkit::Ruler *)jarg1;
79106   arg2 = (float)jarg2;
79107   arg3 = (float)jarg3;
79108   {
79109     try {
79110       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3);
79111     } catch (std::out_of_range& e) {
79112       {
79113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79114       };
79115     } catch (std::exception& e) {
79116       {
79117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79118       };
79119     } catch (Dali::DaliException e) {
79120       {
79121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79122       };
79123     } catch (...) {
79124       {
79125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79126       };
79127     }
79128   }
79129
79130   jresult = result;
79131   return jresult;
79132 }
79133
79134
79135 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_2(void * jarg1, float jarg2) {
79136   float jresult ;
79137   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
79138   float arg2 ;
79139   float result;
79140
79141   arg1 = (Dali::Toolkit::Ruler *)jarg1;
79142   arg2 = (float)jarg2;
79143   {
79144     try {
79145       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2);
79146     } catch (std::out_of_range& e) {
79147       {
79148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79149       };
79150     } catch (std::exception& e) {
79151       {
79152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79153       };
79154     } catch (Dali::DaliException e) {
79155       {
79156         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79157       };
79158     } catch (...) {
79159       {
79160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79161       };
79162     }
79163   }
79164
79165   jresult = result;
79166   return jresult;
79167 }
79168
79169
79170 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
79171   float jresult ;
79172   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
79173   float arg2 ;
79174   float arg3 ;
79175   float arg4 ;
79176   Dali::Toolkit::ClampState *arg5 = 0 ;
79177   float result;
79178
79179   arg1 = (Dali::Toolkit::Ruler *)jarg1;
79180   arg2 = (float)jarg2;
79181   arg3 = (float)jarg3;
79182   arg4 = (float)jarg4;
79183   arg5 = (Dali::Toolkit::ClampState *)jarg5;
79184   if (!arg5) {
79185     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
79186     return 0;
79187   }
79188   {
79189     try {
79190       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
79191     } catch (std::out_of_range& e) {
79192       {
79193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79194       };
79195     } catch (std::exception& e) {
79196       {
79197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79198       };
79199     } catch (Dali::DaliException e) {
79200       {
79201         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79202       };
79203     } catch (...) {
79204       {
79205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79206       };
79207     }
79208   }
79209
79210   jresult = result;
79211   return jresult;
79212 }
79213
79214
79215 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
79216   float jresult ;
79217   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
79218   float arg2 ;
79219   float arg3 ;
79220   float arg4 ;
79221   float arg5 ;
79222   float result;
79223
79224   arg1 = (Dali::Toolkit::Ruler *)jarg1;
79225   arg2 = (float)jarg2;
79226   arg3 = (float)jarg3;
79227   arg4 = (float)jarg4;
79228   arg5 = (float)jarg5;
79229   {
79230     try {
79231       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
79232     } catch (std::out_of_range& e) {
79233       {
79234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79235       };
79236     } catch (std::exception& e) {
79237       {
79238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79239       };
79240     } catch (Dali::DaliException e) {
79241       {
79242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79243       };
79244     } catch (...) {
79245       {
79246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79247       };
79248     }
79249   }
79250
79251   jresult = result;
79252   return jresult;
79253 }
79254
79255
79256 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
79257   float jresult ;
79258   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
79259   float arg2 ;
79260   float arg3 ;
79261   float arg4 ;
79262   float result;
79263
79264   arg1 = (Dali::Toolkit::Ruler *)jarg1;
79265   arg2 = (float)jarg2;
79266   arg3 = (float)jarg3;
79267   arg4 = (float)jarg4;
79268   {
79269     try {
79270       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4);
79271     } catch (std::out_of_range& e) {
79272       {
79273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79274       };
79275     } catch (std::exception& e) {
79276       {
79277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79278       };
79279     } catch (Dali::DaliException e) {
79280       {
79281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79282       };
79283     } catch (...) {
79284       {
79285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79286       };
79287     }
79288   }
79289
79290   jresult = result;
79291   return jresult;
79292 }
79293
79294
79295 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
79296   float jresult ;
79297   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
79298   float arg2 ;
79299   float arg3 ;
79300   float result;
79301
79302   arg1 = (Dali::Toolkit::Ruler *)jarg1;
79303   arg2 = (float)jarg2;
79304   arg3 = (float)jarg3;
79305   {
79306     try {
79307       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3);
79308     } catch (std::out_of_range& e) {
79309       {
79310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79311       };
79312     } catch (std::exception& e) {
79313       {
79314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79315       };
79316     } catch (Dali::DaliException e) {
79317       {
79318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79319       };
79320     } catch (...) {
79321       {
79322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79323       };
79324     }
79325   }
79326
79327   jresult = result;
79328   return jresult;
79329 }
79330
79331
79332 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
79333   float jresult ;
79334   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
79335   float arg2 ;
79336   float result;
79337
79338   arg1 = (Dali::Toolkit::Ruler *)jarg1;
79339   arg2 = (float)jarg2;
79340   {
79341     try {
79342       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2);
79343     } catch (std::out_of_range& e) {
79344       {
79345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79346       };
79347     } catch (std::exception& e) {
79348       {
79349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79350       };
79351     } catch (Dali::DaliException e) {
79352       {
79353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79354       };
79355     } catch (...) {
79356       {
79357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79358       };
79359     }
79360   }
79361
79362   jresult = result;
79363   return jresult;
79364 }
79365
79366
79367 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
79368   float jresult ;
79369   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
79370   float arg2 ;
79371   float arg3 ;
79372   float arg4 ;
79373   float arg5 ;
79374   Dali::Toolkit::ClampState *arg6 = 0 ;
79375   float result;
79376
79377   arg1 = (Dali::Toolkit::Ruler *)jarg1;
79378   arg2 = (float)jarg2;
79379   arg3 = (float)jarg3;
79380   arg4 = (float)jarg4;
79381   arg5 = (float)jarg5;
79382   arg6 = (Dali::Toolkit::ClampState *)jarg6;
79383   if (!arg6) {
79384     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
79385     return 0;
79386   }
79387   {
79388     try {
79389       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
79390     } catch (std::out_of_range& e) {
79391       {
79392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79393       };
79394     } catch (std::exception& e) {
79395       {
79396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79397       };
79398     } catch (Dali::DaliException e) {
79399       {
79400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79401       };
79402     } catch (...) {
79403       {
79404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79405       };
79406     }
79407   }
79408
79409   jresult = result;
79410   return jresult;
79411 }
79412
79413
79414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DefaultRuler() {
79415   void * jresult ;
79416   Dali::Toolkit::DefaultRuler *result = 0 ;
79417
79418   {
79419     try {
79420       result = (Dali::Toolkit::DefaultRuler *)new Dali::Toolkit::DefaultRuler();
79421     } catch (std::out_of_range& e) {
79422       {
79423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79424       };
79425     } catch (std::exception& e) {
79426       {
79427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79428       };
79429     } catch (Dali::DaliException e) {
79430       {
79431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79432       };
79433     } catch (...) {
79434       {
79435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79436       };
79437     }
79438   }
79439
79440   jresult = (void *)result;
79441   return jresult;
79442 }
79443
79444
79445 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_Snap(void * jarg1, float jarg2, float jarg3) {
79446   float jresult ;
79447   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
79448   float arg2 ;
79449   float arg3 ;
79450   float result;
79451
79452   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
79453   arg2 = (float)jarg2;
79454   arg3 = (float)jarg3;
79455   {
79456     try {
79457       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->Snap(arg2,arg3);
79458     } catch (std::out_of_range& e) {
79459       {
79460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79461       };
79462     } catch (std::exception& e) {
79463       {
79464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79465       };
79466     } catch (Dali::DaliException e) {
79467       {
79468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79469       };
79470     } catch (...) {
79471       {
79472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79473       };
79474     }
79475   }
79476
79477   jresult = result;
79478   return jresult;
79479 }
79480
79481
79482 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
79483   float jresult ;
79484   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
79485   unsigned int arg2 ;
79486   unsigned int *arg3 = 0 ;
79487   bool arg4 ;
79488   float result;
79489
79490   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
79491   arg2 = (unsigned int)jarg2;
79492   arg3 = (unsigned int *)jarg3;
79493   arg4 = jarg4 ? true : false;
79494   {
79495     try {
79496       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
79497     } catch (std::out_of_range& e) {
79498       {
79499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79500       };
79501     } catch (std::exception& e) {
79502       {
79503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79504       };
79505     } catch (Dali::DaliException e) {
79506       {
79507         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79508       };
79509     } catch (...) {
79510       {
79511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79512       };
79513     }
79514   }
79515
79516   jresult = result;
79517   return jresult;
79518 }
79519
79520
79521 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
79522   unsigned int jresult ;
79523   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
79524   float arg2 ;
79525   bool arg3 ;
79526   unsigned int result;
79527
79528   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
79529   arg2 = (float)jarg2;
79530   arg3 = jarg3 ? true : false;
79531   {
79532     try {
79533       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
79534     } catch (std::out_of_range& e) {
79535       {
79536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79537       };
79538     } catch (std::exception& e) {
79539       {
79540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79541       };
79542     } catch (Dali::DaliException e) {
79543       {
79544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79545       };
79546     } catch (...) {
79547       {
79548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79549       };
79550     }
79551   }
79552
79553   jresult = result;
79554   return jresult;
79555 }
79556
79557
79558 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetTotalPages(void * jarg1) {
79559   unsigned int jresult ;
79560   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
79561   unsigned int result;
79562
79563   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
79564   {
79565     try {
79566       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetTotalPages();
79567     } catch (std::out_of_range& e) {
79568       {
79569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79570       };
79571     } catch (std::exception& e) {
79572       {
79573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79574       };
79575     } catch (Dali::DaliException e) {
79576       {
79577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79578       };
79579     } catch (...) {
79580       {
79581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79582       };
79583     }
79584   }
79585
79586   jresult = result;
79587   return jresult;
79588 }
79589
79590
79591 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DefaultRuler(void * jarg1) {
79592   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
79593
79594   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
79595   {
79596     try {
79597       delete arg1;
79598     } catch (std::out_of_range& e) {
79599       {
79600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79601       };
79602     } catch (std::exception& e) {
79603       {
79604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79605       };
79606     } catch (Dali::DaliException e) {
79607       {
79608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79609       };
79610     } catch (...) {
79611       {
79612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79613       };
79614     }
79615   }
79616
79617 }
79618
79619
79620 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_0(float jarg1) {
79621   void * jresult ;
79622   float arg1 ;
79623   Dali::Toolkit::FixedRuler *result = 0 ;
79624
79625   arg1 = (float)jarg1;
79626   {
79627     try {
79628       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler(arg1);
79629     } catch (std::out_of_range& e) {
79630       {
79631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79632       };
79633     } catch (std::exception& e) {
79634       {
79635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79636       };
79637     } catch (Dali::DaliException e) {
79638       {
79639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79640       };
79641     } catch (...) {
79642       {
79643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79644       };
79645     }
79646   }
79647
79648   jresult = (void *)result;
79649   return jresult;
79650 }
79651
79652
79653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_1() {
79654   void * jresult ;
79655   Dali::Toolkit::FixedRuler *result = 0 ;
79656
79657   {
79658     try {
79659       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler();
79660     } catch (std::out_of_range& e) {
79661       {
79662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79663       };
79664     } catch (std::exception& e) {
79665       {
79666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79667       };
79668     } catch (Dali::DaliException e) {
79669       {
79670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79671       };
79672     } catch (...) {
79673       {
79674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79675       };
79676     }
79677   }
79678
79679   jresult = (void *)result;
79680   return jresult;
79681 }
79682
79683
79684 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_Snap(void * jarg1, float jarg2, float jarg3) {
79685   float jresult ;
79686   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79687   float arg2 ;
79688   float arg3 ;
79689   float result;
79690
79691   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79692   arg2 = (float)jarg2;
79693   arg3 = (float)jarg3;
79694   {
79695     try {
79696       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->Snap(arg2,arg3);
79697     } catch (std::out_of_range& e) {
79698       {
79699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79700       };
79701     } catch (std::exception& e) {
79702       {
79703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79704       };
79705     } catch (Dali::DaliException e) {
79706       {
79707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79708       };
79709     } catch (...) {
79710       {
79711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79712       };
79713     }
79714   }
79715
79716   jresult = result;
79717   return jresult;
79718 }
79719
79720
79721 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
79722   float jresult ;
79723   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79724   unsigned int arg2 ;
79725   unsigned int *arg3 = 0 ;
79726   bool arg4 ;
79727   float result;
79728
79729   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79730   arg2 = (unsigned int)jarg2;
79731   arg3 = (unsigned int *)jarg3;
79732   arg4 = jarg4 ? true : false;
79733   {
79734     try {
79735       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
79736     } catch (std::out_of_range& e) {
79737       {
79738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79739       };
79740     } catch (std::exception& e) {
79741       {
79742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79743       };
79744     } catch (Dali::DaliException e) {
79745       {
79746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79747       };
79748     } catch (...) {
79749       {
79750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79751       };
79752     }
79753   }
79754
79755   jresult = result;
79756   return jresult;
79757 }
79758
79759
79760 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
79761   unsigned int jresult ;
79762   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79763   float arg2 ;
79764   bool arg3 ;
79765   unsigned int result;
79766
79767   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79768   arg2 = (float)jarg2;
79769   arg3 = jarg3 ? true : false;
79770   {
79771     try {
79772       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
79773     } catch (std::out_of_range& e) {
79774       {
79775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79776       };
79777     } catch (std::exception& e) {
79778       {
79779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79780       };
79781     } catch (Dali::DaliException e) {
79782       {
79783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79784       };
79785     } catch (...) {
79786       {
79787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79788       };
79789     }
79790   }
79791
79792   jresult = result;
79793   return jresult;
79794 }
79795
79796
79797 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetTotalPages(void * jarg1) {
79798   unsigned int jresult ;
79799   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79800   unsigned int result;
79801
79802   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79803   {
79804     try {
79805       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetTotalPages();
79806     } catch (std::out_of_range& e) {
79807       {
79808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79809       };
79810     } catch (std::exception& e) {
79811       {
79812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79813       };
79814     } catch (Dali::DaliException e) {
79815       {
79816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79817       };
79818     } catch (...) {
79819       {
79820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79821       };
79822     }
79823   }
79824
79825   jresult = result;
79826   return jresult;
79827 }
79828
79829
79830 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FixedRuler(void * jarg1) {
79831   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79832
79833   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79834   {
79835     try {
79836       delete arg1;
79837     } catch (std::out_of_range& e) {
79838       {
79839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79840       };
79841     } catch (std::exception& e) {
79842       {
79843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79844       };
79845     } catch (Dali::DaliException e) {
79846       {
79847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79848       };
79849     } catch (...) {
79850       {
79851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79852       };
79853     }
79854   }
79855
79856 }
79857
79858
79859 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_set(void * jarg1, void * jarg2) {
79860   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79861   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
79862
79863   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79864   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
79865   if (arg1) (arg1)->scale = *arg2;
79866 }
79867
79868
79869 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_get(void * jarg1) {
79870   void * jresult ;
79871   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79872   Dali::Toolkit::ClampState2D *result = 0 ;
79873
79874   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79875   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->scale);
79876   jresult = (void *)result;
79877   return jresult;
79878 }
79879
79880
79881 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_set(void * jarg1, void * jarg2) {
79882   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79883   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
79884
79885   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79886   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
79887   if (arg1) (arg1)->position = *arg2;
79888 }
79889
79890
79891 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_get(void * jarg1) {
79892   void * jresult ;
79893   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79894   Dali::Toolkit::ClampState2D *result = 0 ;
79895
79896   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79897   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->position);
79898   jresult = (void *)result;
79899   return jresult;
79900 }
79901
79902
79903 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_set(void * jarg1, int jarg2) {
79904   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79905   Dali::Toolkit::ClampState arg2 ;
79906
79907   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79908   arg2 = (Dali::Toolkit::ClampState)jarg2;
79909   if (arg1) (arg1)->rotation = arg2;
79910 }
79911
79912
79913 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_get(void * jarg1) {
79914   int jresult ;
79915   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79916   Dali::Toolkit::ClampState result;
79917
79918   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79919   result = (Dali::Toolkit::ClampState) ((arg1)->rotation);
79920   jresult = (int)result;
79921   return jresult;
79922 }
79923
79924
79925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_ClampEvent() {
79926   void * jresult ;
79927   Dali::Toolkit::ScrollView::ClampEvent *result = 0 ;
79928
79929   {
79930     try {
79931       result = (Dali::Toolkit::ScrollView::ClampEvent *)new Dali::Toolkit::ScrollView::ClampEvent();
79932     } catch (std::out_of_range& e) {
79933       {
79934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79935       };
79936     } catch (std::exception& e) {
79937       {
79938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79939       };
79940     } catch (Dali::DaliException e) {
79941       {
79942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79943       };
79944     } catch (...) {
79945       {
79946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79947       };
79948     }
79949   }
79950
79951   jresult = (void *)result;
79952   return jresult;
79953 }
79954
79955
79956 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_ClampEvent(void * jarg1) {
79957   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79958
79959   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79960   {
79961     try {
79962       delete arg1;
79963     } catch (std::out_of_range& e) {
79964       {
79965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79966       };
79967     } catch (std::exception& e) {
79968       {
79969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79970       };
79971     } catch (Dali::DaliException e) {
79972       {
79973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79974       };
79975     } catch (...) {
79976       {
79977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79978       };
79979     }
79980   }
79981
79982 }
79983
79984
79985 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_set(void * jarg1, int jarg2) {
79986   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79987   Dali::Toolkit::SnapType arg2 ;
79988
79989   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79990   arg2 = (Dali::Toolkit::SnapType)jarg2;
79991   if (arg1) (arg1)->type = arg2;
79992 }
79993
79994
79995 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_get(void * jarg1) {
79996   int jresult ;
79997   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79998   Dali::Toolkit::SnapType result;
79999
80000   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
80001   result = (Dali::Toolkit::SnapType) ((arg1)->type);
80002   jresult = (int)result;
80003   return jresult;
80004 }
80005
80006
80007 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_set(void * jarg1, void * jarg2) {
80008   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
80009   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
80010
80011   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
80012   arg2 = (Dali::Vector2 *)jarg2;
80013   if (arg1) (arg1)->position = *arg2;
80014 }
80015
80016
80017 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_get(void * jarg1) {
80018   void * jresult ;
80019   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
80020   Dali::Vector2 *result = 0 ;
80021
80022   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
80023   result = (Dali::Vector2 *)& ((arg1)->position);
80024   jresult = (void *)result;
80025   return jresult;
80026 }
80027
80028
80029 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_set(void * jarg1, float jarg2) {
80030   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
80031   float arg2 ;
80032
80033   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
80034   arg2 = (float)jarg2;
80035   if (arg1) (arg1)->duration = arg2;
80036 }
80037
80038
80039 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_get(void * jarg1) {
80040   float jresult ;
80041   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
80042   float result;
80043
80044   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
80045   result = (float) ((arg1)->duration);
80046   jresult = result;
80047   return jresult;
80048 }
80049
80050
80051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_SnapEvent() {
80052   void * jresult ;
80053   Dali::Toolkit::ScrollView::SnapEvent *result = 0 ;
80054
80055   {
80056     try {
80057       result = (Dali::Toolkit::ScrollView::SnapEvent *)new Dali::Toolkit::ScrollView::SnapEvent();
80058     } catch (std::out_of_range& e) {
80059       {
80060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80061       };
80062     } catch (std::exception& e) {
80063       {
80064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80065       };
80066     } catch (Dali::DaliException e) {
80067       {
80068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80069       };
80070     } catch (...) {
80071       {
80072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80073       };
80074     }
80075   }
80076
80077   jresult = (void *)result;
80078   return jresult;
80079 }
80080
80081
80082 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_SnapEvent(void * jarg1) {
80083   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
80084
80085   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
80086   {
80087     try {
80088       delete arg1;
80089     } catch (std::out_of_range& e) {
80090       {
80091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80092       };
80093     } catch (std::exception& e) {
80094       {
80095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80096       };
80097     } catch (Dali::DaliException e) {
80098       {
80099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80100       };
80101     } catch (...) {
80102       {
80103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80104       };
80105     }
80106   }
80107
80108 }
80109
80110
80111 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_ENABLED_get() {
80112   int jresult ;
80113   int result;
80114
80115   result = (int)Dali::Toolkit::ScrollView::Property::WRAP_ENABLED;
80116   jresult = (int)result;
80117   return jresult;
80118 }
80119
80120
80121 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_ENABLED_get() {
80122   int jresult ;
80123   int result;
80124
80125   result = (int)Dali::Toolkit::ScrollView::Property::PANNING_ENABLED;
80126   jresult = (int)result;
80127   return jresult;
80128 }
80129
80130
80131 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_AXIS_AUTO_LOCK_ENABLED_get() {
80132   int jresult ;
80133   int result;
80134
80135   result = (int)Dali::Toolkit::ScrollView::Property::AXIS_AUTO_LOCK_ENABLED;
80136   jresult = (int)result;
80137   return jresult;
80138 }
80139
80140
80141 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
80142   int jresult ;
80143   int result;
80144
80145   result = (int)Dali::Toolkit::ScrollView::Property::WHEEL_SCROLL_DISTANCE_STEP;
80146   jresult = (int)result;
80147   return jresult;
80148 }
80149
80150
80151 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_MODE_get() {
80152   int jresult ;
80153   int result;
80154
80155   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_MODE;
80156   jresult = (int)result;
80157   return jresult;
80158 }
80159
80160 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_get() {
80161   int jresult ;
80162   int result;
80163
80164   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION;
80165   jresult = (int)result;
80166   return jresult;
80167 }
80168
80169
80170 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_get() {
80171   int jresult ;
80172   int result;
80173
80174   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION;
80175   jresult = (int)result;
80176   return jresult;
80177 }
80178
80179
80180 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_X_get() {
80181   int jresult ;
80182   int result;
80183
80184   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_X;
80185   jresult = (int)result;
80186   return jresult;
80187 }
80188
80189
80190 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_Y_get() {
80191   int jresult ;
80192   int result;
80193
80194   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_Y;
80195   jresult = (int)result;
80196   return jresult;
80197 }
80198
80199
80200 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_get() {
80201   int jresult ;
80202   int result;
80203
80204   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX;
80205   jresult = (int)result;
80206   return jresult;
80207 }
80208
80209
80210 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_X_get() {
80211   int jresult ;
80212   int result;
80213
80214   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_X;
80215   jresult = (int)result;
80216   return jresult;
80217 }
80218
80219
80220 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_Y_get() {
80221   int jresult ;
80222   int result;
80223
80224   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_Y;
80225   jresult = (int)result;
80226   return jresult;
80227 }
80228
80229
80230 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_X_get() {
80231   int jresult ;
80232   int result;
80233
80234   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_X;
80235   jresult = (int)result;
80236   return jresult;
80237 }
80238
80239
80240 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_Y_get() {
80241   int jresult ;
80242   int result;
80243
80244   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_Y;
80245   jresult = (int)result;
80246   return jresult;
80247 }
80248
80249
80250 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_get() {
80251   int jresult ;
80252   int result;
80253
80254   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL;
80255   jresult = (int)result;
80256   return jresult;
80257 }
80258
80259
80260 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_X_get() {
80261   int jresult ;
80262   int result;
80263
80264   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_X;
80265   jresult = (int)result;
80266   return jresult;
80267 }
80268
80269
80270 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_Y_get() {
80271   int jresult ;
80272   int result;
80273
80274   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_Y;
80275   jresult = (int)result;
80276   return jresult;
80277 }
80278
80279
80280 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_get() {
80281   int jresult ;
80282   int result;
80283
80284   result = (int)Dali::Toolkit::ScrollView::Property::WRAP;
80285   jresult = (int)result;
80286   return jresult;
80287 }
80288
80289
80290 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_get() {
80291   int jresult ;
80292   int result;
80293
80294   result = (int)Dali::Toolkit::ScrollView::Property::PANNING;
80295   jresult = (int)result;
80296   return jresult;
80297 }
80298
80299
80300 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLLING_get() {
80301   int jresult ;
80302   int result;
80303
80304   result = (int)Dali::Toolkit::ScrollView::Property::SCROLLING;
80305   jresult = (int)result;
80306   return jresult;
80307 }
80308
80309
80310 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_get() {
80311   int jresult ;
80312   int result;
80313
80314   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE;
80315   jresult = (int)result;
80316   return jresult;
80317 }
80318
80319
80320 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_X_get() {
80321   int jresult ;
80322   int result;
80323
80324   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_X;
80325   jresult = (int)result;
80326   return jresult;
80327 }
80328
80329
80330 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_Y_get() {
80331   int jresult ;
80332   int result;
80333
80334   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_Y;
80335   jresult = (int)result;
80336   return jresult;
80337 }
80338
80339
80340 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_OFFSET_get() {
80341   int jresult ;
80342   int result;
80343
80344   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_OFFSET;
80345   jresult = (int)result;
80346   return jresult;
80347 }
80348
80349
80350 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_DELTA_get() {
80351   int jresult ;
80352   int result;
80353
80354   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION_DELTA;
80355   jresult = (int)result;
80356   return jresult;
80357 }
80358
80359
80360 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_START_PAGE_POSITION_get() {
80361   int jresult ;
80362   int result;
80363
80364   result = (int)Dali::Toolkit::ScrollView::Property::START_PAGE_POSITION;
80365   jresult = (int)result;
80366   return jresult;
80367 }
80368
80369
80370 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_Property() {
80371   void * jresult ;
80372   Dali::Toolkit::ScrollView::Property *result = 0 ;
80373
80374   {
80375     try {
80376       result = (Dali::Toolkit::ScrollView::Property *)new Dali::Toolkit::ScrollView::Property();
80377     } catch (std::out_of_range& e) {
80378       {
80379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80380       };
80381     } catch (std::exception& e) {
80382       {
80383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80384       };
80385     } catch (Dali::DaliException e) {
80386       {
80387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80388       };
80389     } catch (...) {
80390       {
80391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80392       };
80393     }
80394   }
80395
80396   jresult = (void *)result;
80397   return jresult;
80398 }
80399
80400
80401 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_Property(void * jarg1) {
80402   Dali::Toolkit::ScrollView::Property *arg1 = (Dali::Toolkit::ScrollView::Property *) 0 ;
80403
80404   arg1 = (Dali::Toolkit::ScrollView::Property *)jarg1;
80405   {
80406     try {
80407       delete arg1;
80408     } catch (std::out_of_range& e) {
80409       {
80410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80411       };
80412     } catch (std::exception& e) {
80413       {
80414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80415       };
80416     } catch (Dali::DaliException e) {
80417       {
80418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80419       };
80420     } catch (...) {
80421       {
80422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80423       };
80424     }
80425   }
80426
80427 }
80428
80429
80430 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_0() {
80431   void * jresult ;
80432   Dali::Toolkit::ScrollView *result = 0 ;
80433
80434   {
80435     try {
80436       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView();
80437     } catch (std::out_of_range& e) {
80438       {
80439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80440       };
80441     } catch (std::exception& e) {
80442       {
80443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80444       };
80445     } catch (Dali::DaliException e) {
80446       {
80447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80448       };
80449     } catch (...) {
80450       {
80451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80452       };
80453     }
80454   }
80455
80456   jresult = (void *)result;
80457   return jresult;
80458 }
80459
80460
80461 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_1(void * jarg1) {
80462   void * jresult ;
80463   Dali::Toolkit::ScrollView *arg1 = 0 ;
80464   Dali::Toolkit::ScrollView *result = 0 ;
80465
80466   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80467   if (!arg1) {
80468     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
80469     return 0;
80470   }
80471   {
80472     try {
80473       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView((Dali::Toolkit::ScrollView const &)*arg1);
80474     } catch (std::out_of_range& e) {
80475       {
80476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80477       };
80478     } catch (std::exception& e) {
80479       {
80480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80481       };
80482     } catch (Dali::DaliException e) {
80483       {
80484         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80485       };
80486     } catch (...) {
80487       {
80488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80489       };
80490     }
80491   }
80492
80493   jresult = (void *)result;
80494   return jresult;
80495 }
80496
80497
80498 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_Assign(void * jarg1, void * jarg2) {
80499   void * jresult ;
80500   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80501   Dali::Toolkit::ScrollView *arg2 = 0 ;
80502   Dali::Toolkit::ScrollView *result = 0 ;
80503
80504   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80505   arg2 = (Dali::Toolkit::ScrollView *)jarg2;
80506   if (!arg2) {
80507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
80508     return 0;
80509   }
80510   {
80511     try {
80512       result = (Dali::Toolkit::ScrollView *) &(arg1)->operator =((Dali::Toolkit::ScrollView const &)*arg2);
80513     } catch (std::out_of_range& e) {
80514       {
80515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80516       };
80517     } catch (std::exception& e) {
80518       {
80519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80520       };
80521     } catch (Dali::DaliException e) {
80522       {
80523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80524       };
80525     } catch (...) {
80526       {
80527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80528       };
80529     }
80530   }
80531
80532   jresult = (void *)result;
80533   return jresult;
80534 }
80535
80536
80537 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView(void * jarg1) {
80538   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80539
80540   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80541   {
80542     try {
80543       delete arg1;
80544     } catch (std::out_of_range& e) {
80545       {
80546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80547       };
80548     } catch (std::exception& e) {
80549       {
80550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80551       };
80552     } catch (Dali::DaliException e) {
80553       {
80554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80555       };
80556     } catch (...) {
80557       {
80558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80559       };
80560     }
80561   }
80562
80563 }
80564
80565
80566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_New() {
80567   void * jresult ;
80568   Dali::Toolkit::ScrollView result;
80569
80570   {
80571     try {
80572       result = Dali::Toolkit::ScrollView::New();
80573     } catch (std::out_of_range& e) {
80574       {
80575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80576       };
80577     } catch (std::exception& e) {
80578       {
80579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80580       };
80581     } catch (Dali::DaliException e) {
80582       {
80583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80584       };
80585     } catch (...) {
80586       {
80587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80588       };
80589     }
80590   }
80591
80592   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
80593   return jresult;
80594 }
80595
80596
80597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_DownCast(void * jarg1) {
80598   void * jresult ;
80599   Dali::BaseHandle arg1 ;
80600   Dali::BaseHandle *argp1 ;
80601   Dali::Toolkit::ScrollView result;
80602
80603   argp1 = (Dali::BaseHandle *)jarg1;
80604   if (!argp1) {
80605     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
80606     return 0;
80607   }
80608   arg1 = *argp1;
80609   {
80610     try {
80611       result = Dali::Toolkit::ScrollView::DownCast(arg1);
80612     } catch (std::out_of_range& e) {
80613       {
80614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80615       };
80616     } catch (std::exception& e) {
80617       {
80618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80619       };
80620     } catch (Dali::DaliException e) {
80621       {
80622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80623       };
80624     } catch (...) {
80625       {
80626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80627       };
80628     }
80629   }
80630
80631   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
80632   return jresult;
80633 }
80634
80635
80636 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapAlphaFunction(void * jarg1) {
80637   void * jresult ;
80638   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80639   Dali::AlphaFunction result;
80640
80641   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80642   {
80643     try {
80644       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapAlphaFunction();
80645     } catch (std::out_of_range& e) {
80646       {
80647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80648       };
80649     } catch (std::exception& e) {
80650       {
80651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80652       };
80653     } catch (Dali::DaliException e) {
80654       {
80655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80656       };
80657     } catch (...) {
80658       {
80659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80660       };
80661     }
80662   }
80663
80664   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
80665   return jresult;
80666 }
80667
80668
80669 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapAlphaFunction(void * jarg1, void * jarg2) {
80670   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80671   Dali::AlphaFunction arg2 ;
80672   Dali::AlphaFunction *argp2 ;
80673
80674   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80675   argp2 = (Dali::AlphaFunction *)jarg2;
80676   if (!argp2) {
80677     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
80678     return ;
80679   }
80680   arg2 = *argp2;
80681   {
80682     try {
80683       (arg1)->SetScrollSnapAlphaFunction(arg2);
80684     } catch (std::out_of_range& e) {
80685       {
80686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80687       };
80688     } catch (std::exception& e) {
80689       {
80690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80691       };
80692     } catch (Dali::DaliException e) {
80693       {
80694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80695       };
80696     } catch (...) {
80697       {
80698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80699       };
80700     }
80701   }
80702
80703 }
80704
80705
80706 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickAlphaFunction(void * jarg1) {
80707   void * jresult ;
80708   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80709   Dali::AlphaFunction result;
80710
80711   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80712   {
80713     try {
80714       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickAlphaFunction();
80715     } catch (std::out_of_range& e) {
80716       {
80717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80718       };
80719     } catch (std::exception& e) {
80720       {
80721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80722       };
80723     } catch (Dali::DaliException e) {
80724       {
80725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80726       };
80727     } catch (...) {
80728       {
80729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80730       };
80731     }
80732   }
80733
80734   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
80735   return jresult;
80736 }
80737
80738
80739 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickAlphaFunction(void * jarg1, void * jarg2) {
80740   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80741   Dali::AlphaFunction arg2 ;
80742   Dali::AlphaFunction *argp2 ;
80743
80744   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80745   argp2 = (Dali::AlphaFunction *)jarg2;
80746   if (!argp2) {
80747     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
80748     return ;
80749   }
80750   arg2 = *argp2;
80751   {
80752     try {
80753       (arg1)->SetScrollFlickAlphaFunction(arg2);
80754     } catch (std::out_of_range& e) {
80755       {
80756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80757       };
80758     } catch (std::exception& e) {
80759       {
80760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80761       };
80762     } catch (Dali::DaliException e) {
80763       {
80764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80765       };
80766     } catch (...) {
80767       {
80768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80769       };
80770     }
80771   }
80772
80773 }
80774
80775
80776 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapDuration(void * jarg1) {
80777   float jresult ;
80778   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80779   float result;
80780
80781   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80782   {
80783     try {
80784       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapDuration();
80785     } catch (std::out_of_range& e) {
80786       {
80787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80788       };
80789     } catch (std::exception& e) {
80790       {
80791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80792       };
80793     } catch (Dali::DaliException e) {
80794       {
80795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80796       };
80797     } catch (...) {
80798       {
80799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80800       };
80801     }
80802   }
80803
80804   jresult = result;
80805   return jresult;
80806 }
80807
80808
80809 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapDuration(void * jarg1, float jarg2) {
80810   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80811   float arg2 ;
80812
80813   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80814   arg2 = (float)jarg2;
80815   {
80816     try {
80817       (arg1)->SetScrollSnapDuration(arg2);
80818     } catch (std::out_of_range& e) {
80819       {
80820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80821       };
80822     } catch (std::exception& e) {
80823       {
80824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80825       };
80826     } catch (Dali::DaliException e) {
80827       {
80828         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80829       };
80830     } catch (...) {
80831       {
80832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80833       };
80834     }
80835   }
80836
80837 }
80838
80839
80840 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickDuration(void * jarg1) {
80841   float jresult ;
80842   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80843   float result;
80844
80845   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80846   {
80847     try {
80848       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickDuration();
80849     } catch (std::out_of_range& e) {
80850       {
80851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80852       };
80853     } catch (std::exception& e) {
80854       {
80855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80856       };
80857     } catch (Dali::DaliException e) {
80858       {
80859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80860       };
80861     } catch (...) {
80862       {
80863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80864       };
80865     }
80866   }
80867
80868   jresult = result;
80869   return jresult;
80870 }
80871
80872
80873 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickDuration(void * jarg1, float jarg2) {
80874   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80875   float arg2 ;
80876
80877   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80878   arg2 = (float)jarg2;
80879   {
80880     try {
80881       (arg1)->SetScrollFlickDuration(arg2);
80882     } catch (std::out_of_range& e) {
80883       {
80884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80885       };
80886     } catch (std::exception& e) {
80887       {
80888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80889       };
80890     } catch (Dali::DaliException e) {
80891       {
80892         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80893       };
80894     } catch (...) {
80895       {
80896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80897       };
80898     }
80899   }
80900
80901 }
80902
80903
80904 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerX(void * jarg1, void * jarg2) {
80905   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80906   Dali::Toolkit::RulerPtr arg2 ;
80907   Dali::Toolkit::RulerPtr *argp2 ;
80908
80909   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80910   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
80911   if (!argp2) {
80912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
80913     return ;
80914   }
80915   arg2 = *argp2;
80916   {
80917     try {
80918       (arg1)->SetRulerX(arg2);
80919     } catch (std::out_of_range& e) {
80920       {
80921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80922       };
80923     } catch (std::exception& e) {
80924       {
80925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80926       };
80927     } catch (Dali::DaliException e) {
80928       {
80929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80930       };
80931     } catch (...) {
80932       {
80933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80934       };
80935     }
80936   }
80937
80938 }
80939
80940
80941 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerY(void * jarg1, void * jarg2) {
80942   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80943   Dali::Toolkit::RulerPtr arg2 ;
80944   Dali::Toolkit::RulerPtr *argp2 ;
80945
80946   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80947   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
80948   if (!argp2) {
80949     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
80950     return ;
80951   }
80952   arg2 = *argp2;
80953   {
80954     try {
80955       (arg1)->SetRulerY(arg2);
80956     } catch (std::out_of_range& e) {
80957       {
80958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80959       };
80960     } catch (std::exception& e) {
80961       {
80962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80963       };
80964     } catch (Dali::DaliException e) {
80965       {
80966         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80967       };
80968     } catch (...) {
80969       {
80970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80971       };
80972     }
80973   }
80974
80975 }
80976
80977
80978 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSensitive(void * jarg1, unsigned int jarg2) {
80979   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80980   bool arg2 ;
80981
80982   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80983   arg2 = jarg2 ? true : false;
80984   {
80985     try {
80986       (arg1)->SetScrollSensitive(arg2);
80987     } catch (std::out_of_range& e) {
80988       {
80989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80990       };
80991     } catch (std::exception& e) {
80992       {
80993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80994       };
80995     } catch (Dali::DaliException e) {
80996       {
80997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80998       };
80999     } catch (...) {
81000       {
81001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81002       };
81003     }
81004   }
81005
81006 }
81007
81008
81009 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxOvershoot(void * jarg1, float jarg2, float jarg3) {
81010   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81011   float arg2 ;
81012   float arg3 ;
81013
81014   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81015   arg2 = (float)jarg2;
81016   arg3 = (float)jarg3;
81017   {
81018     try {
81019       (arg1)->SetMaxOvershoot(arg2,arg3);
81020     } catch (std::out_of_range& e) {
81021       {
81022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81023       };
81024     } catch (std::exception& e) {
81025       {
81026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81027       };
81028     } catch (Dali::DaliException e) {
81029       {
81030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81031       };
81032     } catch (...) {
81033       {
81034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81035       };
81036     }
81037   }
81038
81039 }
81040
81041
81042 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootAlphaFunction(void * jarg1, void * jarg2) {
81043   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81044   Dali::AlphaFunction arg2 ;
81045   Dali::AlphaFunction *argp2 ;
81046
81047   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81048   argp2 = (Dali::AlphaFunction *)jarg2;
81049   if (!argp2) {
81050     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
81051     return ;
81052   }
81053   arg2 = *argp2;
81054   {
81055     try {
81056       (arg1)->SetSnapOvershootAlphaFunction(arg2);
81057     } catch (std::out_of_range& e) {
81058       {
81059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81060       };
81061     } catch (std::exception& e) {
81062       {
81063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81064       };
81065     } catch (Dali::DaliException e) {
81066       {
81067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81068       };
81069     } catch (...) {
81070       {
81071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81072       };
81073     }
81074   }
81075
81076 }
81077
81078
81079 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootDuration(void * jarg1, float jarg2) {
81080   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81081   float arg2 ;
81082
81083   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81084   arg2 = (float)jarg2;
81085   {
81086     try {
81087       (arg1)->SetSnapOvershootDuration(arg2);
81088     } catch (std::out_of_range& e) {
81089       {
81090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81091       };
81092     } catch (std::exception& e) {
81093       {
81094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81095       };
81096     } catch (Dali::DaliException e) {
81097       {
81098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81099       };
81100     } catch (...) {
81101       {
81102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81103       };
81104     }
81105   }
81106
81107 }
81108
81109
81110 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetActorAutoSnap(void * jarg1, unsigned int jarg2) {
81111   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81112   bool arg2 ;
81113
81114   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81115   arg2 = jarg2 ? true : false;
81116   {
81117     try {
81118       (arg1)->SetActorAutoSnap(arg2);
81119     } catch (std::out_of_range& e) {
81120       {
81121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81122       };
81123     } catch (std::exception& e) {
81124       {
81125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81126       };
81127     } catch (Dali::DaliException e) {
81128       {
81129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81130       };
81131     } catch (...) {
81132       {
81133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81134       };
81135     }
81136   }
81137
81138 }
81139
81140
81141 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWrapMode(void * jarg1, unsigned int jarg2) {
81142   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81143   bool arg2 ;
81144
81145   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81146   arg2 = jarg2 ? true : false;
81147   {
81148     try {
81149       (arg1)->SetWrapMode(arg2);
81150     } catch (std::out_of_range& e) {
81151       {
81152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81153       };
81154     } catch (std::exception& e) {
81155       {
81156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81157       };
81158     } catch (Dali::DaliException e) {
81159       {
81160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81161       };
81162     } catch (...) {
81163       {
81164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81165       };
81166     }
81167   }
81168
81169 }
81170
81171
81172 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollUpdateDistance(void * jarg1) {
81173   int jresult ;
81174   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81175   int result;
81176
81177   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81178   {
81179     try {
81180       result = (int)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollUpdateDistance();
81181     } catch (std::out_of_range& e) {
81182       {
81183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81184       };
81185     } catch (std::exception& e) {
81186       {
81187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81188       };
81189     } catch (Dali::DaliException e) {
81190       {
81191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81192       };
81193     } catch (...) {
81194       {
81195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81196       };
81197     }
81198   }
81199
81200   jresult = result;
81201   return jresult;
81202 }
81203
81204
81205 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollUpdateDistance(void * jarg1, int jarg2) {
81206   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81207   int arg2 ;
81208
81209   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81210   arg2 = (int)jarg2;
81211   {
81212     try {
81213       (arg1)->SetScrollUpdateDistance(arg2);
81214     } catch (std::out_of_range& e) {
81215       {
81216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81217       };
81218     } catch (std::exception& e) {
81219       {
81220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81221       };
81222     } catch (Dali::DaliException e) {
81223       {
81224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81225       };
81226     } catch (...) {
81227       {
81228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81229       };
81230     }
81231   }
81232
81233 }
81234
81235
81236 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLock(void * jarg1) {
81237   unsigned int jresult ;
81238   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81239   bool result;
81240
81241   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81242   {
81243     try {
81244       result = (bool)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLock();
81245     } catch (std::out_of_range& e) {
81246       {
81247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81248       };
81249     } catch (std::exception& e) {
81250       {
81251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81252       };
81253     } catch (Dali::DaliException e) {
81254       {
81255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81256       };
81257     } catch (...) {
81258       {
81259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81260       };
81261     }
81262   }
81263
81264   jresult = result;
81265   return jresult;
81266 }
81267
81268
81269 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLock(void * jarg1, unsigned int jarg2) {
81270   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81271   bool arg2 ;
81272
81273   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81274   arg2 = jarg2 ? true : false;
81275   {
81276     try {
81277       (arg1)->SetAxisAutoLock(arg2);
81278     } catch (std::out_of_range& e) {
81279       {
81280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81281       };
81282     } catch (std::exception& e) {
81283       {
81284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81285       };
81286     } catch (Dali::DaliException e) {
81287       {
81288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81289       };
81290     } catch (...) {
81291       {
81292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81293       };
81294     }
81295   }
81296
81297 }
81298
81299
81300 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLockGradient(void * jarg1) {
81301   float jresult ;
81302   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81303   float result;
81304
81305   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81306   {
81307     try {
81308       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLockGradient();
81309     } catch (std::out_of_range& e) {
81310       {
81311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81312       };
81313     } catch (std::exception& e) {
81314       {
81315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81316       };
81317     } catch (Dali::DaliException e) {
81318       {
81319         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81320       };
81321     } catch (...) {
81322       {
81323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81324       };
81325     }
81326   }
81327
81328   jresult = result;
81329   return jresult;
81330 }
81331
81332
81333 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLockGradient(void * jarg1, float jarg2) {
81334   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81335   float arg2 ;
81336
81337   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81338   arg2 = (float)jarg2;
81339   {
81340     try {
81341       (arg1)->SetAxisAutoLockGradient(arg2);
81342     } catch (std::out_of_range& e) {
81343       {
81344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81345       };
81346     } catch (std::exception& e) {
81347       {
81348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81349       };
81350     } catch (Dali::DaliException e) {
81351       {
81352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81353       };
81354     } catch (...) {
81355       {
81356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81357       };
81358     }
81359   }
81360
81361 }
81362
81363
81364 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFrictionCoefficient(void * jarg1) {
81365   float jresult ;
81366   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81367   float result;
81368
81369   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81370   {
81371     try {
81372       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFrictionCoefficient();
81373     } catch (std::out_of_range& e) {
81374       {
81375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81376       };
81377     } catch (std::exception& e) {
81378       {
81379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81380       };
81381     } catch (Dali::DaliException e) {
81382       {
81383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81384       };
81385     } catch (...) {
81386       {
81387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81388       };
81389     }
81390   }
81391
81392   jresult = result;
81393   return jresult;
81394 }
81395
81396
81397 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFrictionCoefficient(void * jarg1, float jarg2) {
81398   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81399   float arg2 ;
81400
81401   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81402   arg2 = (float)jarg2;
81403   {
81404     try {
81405       (arg1)->SetFrictionCoefficient(arg2);
81406     } catch (std::out_of_range& e) {
81407       {
81408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81409       };
81410     } catch (std::exception& e) {
81411       {
81412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81413       };
81414     } catch (Dali::DaliException e) {
81415       {
81416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81417       };
81418     } catch (...) {
81419       {
81420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81421       };
81422     }
81423   }
81424
81425 }
81426
81427
81428 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFlickSpeedCoefficient(void * jarg1) {
81429   float jresult ;
81430   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81431   float result;
81432
81433   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81434   {
81435     try {
81436       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFlickSpeedCoefficient();
81437     } catch (std::out_of_range& e) {
81438       {
81439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81440       };
81441     } catch (std::exception& e) {
81442       {
81443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81444       };
81445     } catch (Dali::DaliException e) {
81446       {
81447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81448       };
81449     } catch (...) {
81450       {
81451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81452       };
81453     }
81454   }
81455
81456   jresult = result;
81457   return jresult;
81458 }
81459
81460
81461 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFlickSpeedCoefficient(void * jarg1, float jarg2) {
81462   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81463   float arg2 ;
81464
81465   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81466   arg2 = (float)jarg2;
81467   {
81468     try {
81469       (arg1)->SetFlickSpeedCoefficient(arg2);
81470     } catch (std::out_of_range& e) {
81471       {
81472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81473       };
81474     } catch (std::exception& e) {
81475       {
81476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81477       };
81478     } catch (Dali::DaliException e) {
81479       {
81480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81481       };
81482     } catch (...) {
81483       {
81484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81485       };
81486     }
81487   }
81488
81489 }
81490
81491
81492 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumDistanceForFlick(void * jarg1) {
81493   void * jresult ;
81494   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81495   Dali::Vector2 result;
81496
81497   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81498   {
81499     try {
81500       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumDistanceForFlick();
81501     } catch (std::out_of_range& e) {
81502       {
81503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81504       };
81505     } catch (std::exception& e) {
81506       {
81507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81508       };
81509     } catch (Dali::DaliException e) {
81510       {
81511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81512       };
81513     } catch (...) {
81514       {
81515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81516       };
81517     }
81518   }
81519
81520   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
81521   return jresult;
81522 }
81523
81524
81525 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumDistanceForFlick(void * jarg1, void * jarg2) {
81526   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81527   Dali::Vector2 *arg2 = 0 ;
81528
81529   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81530   arg2 = (Dali::Vector2 *)jarg2;
81531   if (!arg2) {
81532     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81533     return ;
81534   }
81535   {
81536     try {
81537       (arg1)->SetMinimumDistanceForFlick((Dali::Vector2 const &)*arg2);
81538     } catch (std::out_of_range& e) {
81539       {
81540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81541       };
81542     } catch (std::exception& e) {
81543       {
81544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81545       };
81546     } catch (Dali::DaliException e) {
81547       {
81548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81549       };
81550     } catch (...) {
81551       {
81552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81553       };
81554     }
81555   }
81556
81557 }
81558
81559
81560 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumSpeedForFlick(void * jarg1) {
81561   float jresult ;
81562   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81563   float result;
81564
81565   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81566   {
81567     try {
81568       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumSpeedForFlick();
81569     } catch (std::out_of_range& e) {
81570       {
81571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81572       };
81573     } catch (std::exception& e) {
81574       {
81575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81576       };
81577     } catch (Dali::DaliException e) {
81578       {
81579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81580       };
81581     } catch (...) {
81582       {
81583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81584       };
81585     }
81586   }
81587
81588   jresult = result;
81589   return jresult;
81590 }
81591
81592
81593 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumSpeedForFlick(void * jarg1, float jarg2) {
81594   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81595   float arg2 ;
81596
81597   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81598   arg2 = (float)jarg2;
81599   {
81600     try {
81601       (arg1)->SetMinimumSpeedForFlick(arg2);
81602     } catch (std::out_of_range& e) {
81603       {
81604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81605       };
81606     } catch (std::exception& e) {
81607       {
81608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81609       };
81610     } catch (Dali::DaliException e) {
81611       {
81612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81613       };
81614     } catch (...) {
81615       {
81616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81617       };
81618     }
81619   }
81620
81621 }
81622
81623
81624 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMaxFlickSpeed(void * jarg1) {
81625   float jresult ;
81626   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81627   float result;
81628
81629   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81630   {
81631     try {
81632       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMaxFlickSpeed();
81633     } catch (std::out_of_range& e) {
81634       {
81635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81636       };
81637     } catch (std::exception& e) {
81638       {
81639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81640       };
81641     } catch (Dali::DaliException e) {
81642       {
81643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81644       };
81645     } catch (...) {
81646       {
81647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81648       };
81649     }
81650   }
81651
81652   jresult = result;
81653   return jresult;
81654 }
81655
81656
81657 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxFlickSpeed(void * jarg1, float jarg2) {
81658   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81659   float arg2 ;
81660
81661   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81662   arg2 = (float)jarg2;
81663   {
81664     try {
81665       (arg1)->SetMaxFlickSpeed(arg2);
81666     } catch (std::out_of_range& e) {
81667       {
81668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81669       };
81670     } catch (std::exception& e) {
81671       {
81672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81673       };
81674     } catch (Dali::DaliException e) {
81675       {
81676         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81677       };
81678     } catch (...) {
81679       {
81680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81681       };
81682     }
81683   }
81684
81685 }
81686
81687
81688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetWheelScrollDistanceStep(void * jarg1) {
81689   void * jresult ;
81690   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81691   Dali::Vector2 result;
81692
81693   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81694   {
81695     try {
81696       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetWheelScrollDistanceStep();
81697     } catch (std::out_of_range& e) {
81698       {
81699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81700       };
81701     } catch (std::exception& e) {
81702       {
81703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81704       };
81705     } catch (Dali::DaliException e) {
81706       {
81707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81708       };
81709     } catch (...) {
81710       {
81711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81712       };
81713     }
81714   }
81715
81716   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
81717   return jresult;
81718 }
81719
81720
81721 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWheelScrollDistanceStep(void * jarg1, void * jarg2) {
81722   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81723   Dali::Vector2 arg2 ;
81724   Dali::Vector2 *argp2 ;
81725
81726   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81727   argp2 = (Dali::Vector2 *)jarg2;
81728   if (!argp2) {
81729     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
81730     return ;
81731   }
81732   arg2 = *argp2;
81733   {
81734     try {
81735       (arg1)->SetWheelScrollDistanceStep(arg2);
81736     } catch (std::out_of_range& e) {
81737       {
81738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81739       };
81740     } catch (std::exception& e) {
81741       {
81742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81743       };
81744     } catch (Dali::DaliException e) {
81745       {
81746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81747       };
81748     } catch (...) {
81749       {
81750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81751       };
81752     }
81753   }
81754
81755 }
81756
81757
81758 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentScrollPosition(void * jarg1) {
81759   void * jresult ;
81760   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81761   Dali::Vector2 result;
81762
81763   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81764   {
81765     try {
81766       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentScrollPosition();
81767     } catch (std::out_of_range& e) {
81768       {
81769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81770       };
81771     } catch (std::exception& e) {
81772       {
81773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81774       };
81775     } catch (Dali::DaliException e) {
81776       {
81777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81778       };
81779     } catch (...) {
81780       {
81781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81782       };
81783     }
81784   }
81785
81786   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
81787   return jresult;
81788 }
81789
81790
81791 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentPage(void * jarg1) {
81792   unsigned int jresult ;
81793   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81794   unsigned int result;
81795
81796   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81797   {
81798     try {
81799       result = (unsigned int)((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentPage();
81800     } catch (std::out_of_range& e) {
81801       {
81802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81803       };
81804     } catch (std::exception& e) {
81805       {
81806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81807       };
81808     } catch (Dali::DaliException e) {
81809       {
81810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81811       };
81812     } catch (...) {
81813       {
81814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81815       };
81816     }
81817   }
81818
81819   jresult = result;
81820   return jresult;
81821 }
81822
81823
81824 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_0(void * jarg1, void * jarg2) {
81825   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81826   Dali::Vector2 *arg2 = 0 ;
81827
81828   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81829   arg2 = (Dali::Vector2 *)jarg2;
81830   if (!arg2) {
81831     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81832     return ;
81833   }
81834   {
81835     try {
81836       (arg1)->ScrollTo((Dali::Vector2 const &)*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_1(void * jarg1, void * jarg2, float jarg3) {
81860   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81861   Dali::Vector2 *arg2 = 0 ;
81862   float arg3 ;
81863
81864   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81865   arg2 = (Dali::Vector2 *)jarg2;
81866   if (!arg2) {
81867     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81868     return ;
81869   }
81870   arg3 = (float)jarg3;
81871   {
81872     try {
81873       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3);
81874     } catch (std::out_of_range& e) {
81875       {
81876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81877       };
81878     } catch (std::exception& e) {
81879       {
81880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81881       };
81882     } catch (Dali::DaliException e) {
81883       {
81884         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81885       };
81886     } catch (...) {
81887       {
81888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81889       };
81890     }
81891   }
81892
81893 }
81894
81895
81896 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_2(void * jarg1, void * jarg2, float jarg3, void * jarg4) {
81897   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81898   Dali::Vector2 *arg2 = 0 ;
81899   float arg3 ;
81900   Dali::AlphaFunction arg4 ;
81901   Dali::AlphaFunction *argp4 ;
81902
81903   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81904   arg2 = (Dali::Vector2 *)jarg2;
81905   if (!arg2) {
81906     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81907     return ;
81908   }
81909   arg3 = (float)jarg3;
81910   argp4 = (Dali::AlphaFunction *)jarg4;
81911   if (!argp4) {
81912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
81913     return ;
81914   }
81915   arg4 = *argp4;
81916   {
81917     try {
81918       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4);
81919     } catch (std::out_of_range& e) {
81920       {
81921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81922       };
81923     } catch (std::exception& e) {
81924       {
81925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81926       };
81927     } catch (Dali::DaliException e) {
81928       {
81929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81930       };
81931     } catch (...) {
81932       {
81933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81934       };
81935     }
81936   }
81937
81938 }
81939
81940
81941 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_3(void * jarg1, void * jarg2, float jarg3, int jarg4, int jarg5) {
81942   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81943   Dali::Vector2 *arg2 = 0 ;
81944   float arg3 ;
81945   Dali::Toolkit::DirectionBias arg4 ;
81946   Dali::Toolkit::DirectionBias arg5 ;
81947
81948   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81949   arg2 = (Dali::Vector2 *)jarg2;
81950   if (!arg2) {
81951     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81952     return ;
81953   }
81954   arg3 = (float)jarg3;
81955   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
81956   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
81957   {
81958     try {
81959       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5);
81960     } catch (std::out_of_range& e) {
81961       {
81962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81963       };
81964     } catch (std::exception& e) {
81965       {
81966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81967       };
81968     } catch (Dali::DaliException e) {
81969       {
81970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81971       };
81972     } catch (...) {
81973       {
81974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81975       };
81976     }
81977   }
81978
81979 }
81980
81981
81982 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_4(void * jarg1, void * jarg2, float jarg3, void * jarg4, int jarg5, int jarg6) {
81983   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81984   Dali::Vector2 *arg2 = 0 ;
81985   float arg3 ;
81986   Dali::AlphaFunction arg4 ;
81987   Dali::Toolkit::DirectionBias arg5 ;
81988   Dali::Toolkit::DirectionBias arg6 ;
81989   Dali::AlphaFunction *argp4 ;
81990
81991   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81992   arg2 = (Dali::Vector2 *)jarg2;
81993   if (!arg2) {
81994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81995     return ;
81996   }
81997   arg3 = (float)jarg3;
81998   argp4 = (Dali::AlphaFunction *)jarg4;
81999   if (!argp4) {
82000     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
82001     return ;
82002   }
82003   arg4 = *argp4;
82004   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
82005   arg6 = (Dali::Toolkit::DirectionBias)jarg6;
82006   {
82007     try {
82008       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5,arg6);
82009     } catch (std::out_of_range& e) {
82010       {
82011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82012       };
82013     } catch (std::exception& e) {
82014       {
82015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82016       };
82017     } catch (Dali::DaliException e) {
82018       {
82019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82020       };
82021     } catch (...) {
82022       {
82023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82024       };
82025     }
82026   }
82027
82028 }
82029
82030
82031 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_5(void * jarg1, unsigned int jarg2) {
82032   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82033   unsigned int arg2 ;
82034
82035   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82036   arg2 = (unsigned int)jarg2;
82037   {
82038     try {
82039       (arg1)->ScrollTo(arg2);
82040     } catch (std::out_of_range& e) {
82041       {
82042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82043       };
82044     } catch (std::exception& e) {
82045       {
82046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82047       };
82048     } catch (Dali::DaliException e) {
82049       {
82050         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82051       };
82052     } catch (...) {
82053       {
82054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82055       };
82056     }
82057   }
82058
82059 }
82060
82061
82062 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_6(void * jarg1, unsigned int jarg2, float jarg3) {
82063   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82064   unsigned int arg2 ;
82065   float arg3 ;
82066
82067   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82068   arg2 = (unsigned int)jarg2;
82069   arg3 = (float)jarg3;
82070   {
82071     try {
82072       (arg1)->ScrollTo(arg2,arg3);
82073     } catch (std::out_of_range& e) {
82074       {
82075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82076       };
82077     } catch (std::exception& e) {
82078       {
82079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82080       };
82081     } catch (Dali::DaliException e) {
82082       {
82083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82084       };
82085     } catch (...) {
82086       {
82087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82088       };
82089     }
82090   }
82091
82092 }
82093
82094
82095 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_7(void * jarg1, unsigned int jarg2, float jarg3, int jarg4) {
82096   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82097   unsigned int arg2 ;
82098   float arg3 ;
82099   Dali::Toolkit::DirectionBias arg4 ;
82100
82101   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82102   arg2 = (unsigned int)jarg2;
82103   arg3 = (float)jarg3;
82104   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
82105   {
82106     try {
82107       (arg1)->ScrollTo(arg2,arg3,arg4);
82108     } catch (std::out_of_range& e) {
82109       {
82110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82111       };
82112     } catch (std::exception& e) {
82113       {
82114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82115       };
82116     } catch (Dali::DaliException e) {
82117       {
82118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82119       };
82120     } catch (...) {
82121       {
82122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82123       };
82124     }
82125   }
82126
82127 }
82128
82129
82130 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_8(void * jarg1, void * jarg2) {
82131   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82132   Dali::Actor *arg2 = 0 ;
82133
82134   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82135   arg2 = (Dali::Actor *)jarg2;
82136   if (!arg2) {
82137     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
82138     return ;
82139   }
82140   {
82141     try {
82142       (arg1)->ScrollTo(*arg2);
82143     } catch (std::out_of_range& e) {
82144       {
82145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82146       };
82147     } catch (std::exception& e) {
82148       {
82149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82150       };
82151     } catch (Dali::DaliException e) {
82152       {
82153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82154       };
82155     } catch (...) {
82156       {
82157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82158       };
82159     }
82160   }
82161
82162 }
82163
82164
82165 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_9(void * jarg1, void * jarg2, float jarg3) {
82166   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82167   Dali::Actor *arg2 = 0 ;
82168   float arg3 ;
82169
82170   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82171   arg2 = (Dali::Actor *)jarg2;
82172   if (!arg2) {
82173     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
82174     return ;
82175   }
82176   arg3 = (float)jarg3;
82177   {
82178     try {
82179       (arg1)->ScrollTo(*arg2,arg3);
82180     } catch (std::out_of_range& e) {
82181       {
82182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82183       };
82184     } catch (std::exception& e) {
82185       {
82186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82187       };
82188     } catch (Dali::DaliException e) {
82189       {
82190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82191       };
82192     } catch (...) {
82193       {
82194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82195       };
82196     }
82197   }
82198
82199 }
82200
82201
82202 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_ScrollToSnapPoint(void * jarg1) {
82203   unsigned int jresult ;
82204   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82205   bool result;
82206
82207   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82208   {
82209     try {
82210       result = (bool)(arg1)->ScrollToSnapPoint();
82211     } catch (std::out_of_range& e) {
82212       {
82213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82214       };
82215     } catch (std::exception& e) {
82216       {
82217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82218       };
82219     } catch (Dali::DaliException e) {
82220       {
82221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82222       };
82223     } catch (...) {
82224       {
82225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82226       };
82227     }
82228   }
82229
82230   jresult = result;
82231   return jresult;
82232 }
82233
82234
82235 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyConstraintToChildren(void * jarg1, void * jarg2) {
82236   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82237   Dali::Constraint arg2 ;
82238   Dali::Constraint *argp2 ;
82239
82240   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82241   argp2 = (Dali::Constraint *)jarg2;
82242   if (!argp2) {
82243     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Constraint", 0);
82244     return ;
82245   }
82246   arg2 = *argp2;
82247   {
82248     try {
82249       (arg1)->ApplyConstraintToChildren(arg2);
82250     } catch (std::out_of_range& e) {
82251       {
82252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82253       };
82254     } catch (std::exception& e) {
82255       {
82256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82257       };
82258     } catch (Dali::DaliException e) {
82259       {
82260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82261       };
82262     } catch (...) {
82263       {
82264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82265       };
82266     }
82267   }
82268
82269 }
82270
82271
82272 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveConstraintsFromChildren(void * jarg1) {
82273   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82274
82275   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82276   {
82277     try {
82278       (arg1)->RemoveConstraintsFromChildren();
82279     } catch (std::out_of_range& e) {
82280       {
82281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82282       };
82283     } catch (std::exception& e) {
82284       {
82285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82286       };
82287     } catch (Dali::DaliException e) {
82288       {
82289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82290       };
82291     } catch (...) {
82292       {
82293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82294       };
82295     }
82296   }
82297
82298 }
82299
82300
82301 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyEffect(void * jarg1, void * jarg2) {
82302   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82303   Dali::Toolkit::ScrollViewEffect arg2 ;
82304   Dali::Toolkit::ScrollViewEffect *argp2 ;
82305
82306   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82307   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
82308   if (!argp2) {
82309     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
82310     return ;
82311   }
82312   arg2 = *argp2;
82313   {
82314     try {
82315       (arg1)->ApplyEffect(arg2);
82316     } catch (std::out_of_range& e) {
82317       {
82318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82319       };
82320     } catch (std::exception& e) {
82321       {
82322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82323       };
82324     } catch (Dali::DaliException e) {
82325       {
82326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82327       };
82328     } catch (...) {
82329       {
82330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82331       };
82332     }
82333   }
82334
82335 }
82336
82337
82338 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveEffect(void * jarg1, void * jarg2) {
82339   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82340   Dali::Toolkit::ScrollViewEffect arg2 ;
82341   Dali::Toolkit::ScrollViewEffect *argp2 ;
82342
82343   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82344   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
82345   if (!argp2) {
82346     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
82347     return ;
82348   }
82349   arg2 = *argp2;
82350   {
82351     try {
82352       (arg1)->RemoveEffect(arg2);
82353     } catch (std::out_of_range& e) {
82354       {
82355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82356       };
82357     } catch (std::exception& e) {
82358       {
82359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82360       };
82361     } catch (Dali::DaliException e) {
82362       {
82363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82364       };
82365     } catch (...) {
82366       {
82367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82368       };
82369     }
82370   }
82371
82372 }
82373
82374
82375 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveAllEffects(void * jarg1) {
82376   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82377
82378   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82379   {
82380     try {
82381       (arg1)->RemoveAllEffects();
82382     } catch (std::out_of_range& e) {
82383       {
82384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82385       };
82386     } catch (std::exception& e) {
82387       {
82388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82389       };
82390     } catch (Dali::DaliException e) {
82391       {
82392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82393       };
82394     } catch (...) {
82395       {
82396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82397       };
82398     }
82399   }
82400
82401 }
82402
82403
82404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_BindActor(void * jarg1, void * jarg2) {
82405   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82406   Dali::Actor arg2 ;
82407   Dali::Actor *argp2 ;
82408
82409   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82410   argp2 = (Dali::Actor *)jarg2;
82411   if (!argp2) {
82412     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82413     return ;
82414   }
82415   arg2 = *argp2;
82416   {
82417     try {
82418       (arg1)->BindActor(arg2);
82419     } catch (std::out_of_range& e) {
82420       {
82421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82422       };
82423     } catch (std::exception& e) {
82424       {
82425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82426       };
82427     } catch (Dali::DaliException e) {
82428       {
82429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82430       };
82431     } catch (...) {
82432       {
82433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82434       };
82435     }
82436   }
82437
82438 }
82439
82440
82441 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_UnbindActor(void * jarg1, void * jarg2) {
82442   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82443   Dali::Actor arg2 ;
82444   Dali::Actor *argp2 ;
82445
82446   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82447   argp2 = (Dali::Actor *)jarg2;
82448   if (!argp2) {
82449     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82450     return ;
82451   }
82452   arg2 = *argp2;
82453   {
82454     try {
82455       (arg1)->UnbindActor(arg2);
82456     } catch (std::out_of_range& e) {
82457       {
82458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82459       };
82460     } catch (std::exception& e) {
82461       {
82462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82463       };
82464     } catch (Dali::DaliException e) {
82465       {
82466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82467       };
82468     } catch (...) {
82469       {
82470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82471       };
82472     }
82473   }
82474
82475 }
82476
82477
82478 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
82479   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82480   Dali::Radian arg2 ;
82481   Dali::Radian arg3 ;
82482   Dali::Radian *argp2 ;
82483   Dali::Radian *argp3 ;
82484
82485   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82486   argp2 = (Dali::Radian *)jarg2;
82487   if (!argp2) {
82488     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
82489     return ;
82490   }
82491   arg2 = *argp2;
82492   argp3 = (Dali::Radian *)jarg3;
82493   if (!argp3) {
82494     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
82495     return ;
82496   }
82497   arg3 = *argp3;
82498   {
82499     try {
82500       (arg1)->SetScrollingDirection(arg2,arg3);
82501     } catch (std::out_of_range& e) {
82502       {
82503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82504       };
82505     } catch (std::exception& e) {
82506       {
82507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82508       };
82509     } catch (Dali::DaliException e) {
82510       {
82511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82512       };
82513     } catch (...) {
82514       {
82515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82516       };
82517     }
82518   }
82519
82520 }
82521
82522
82523 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_1(void * jarg1, void * jarg2) {
82524   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82525   Dali::Radian arg2 ;
82526   Dali::Radian *argp2 ;
82527
82528   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82529   argp2 = (Dali::Radian *)jarg2;
82530   if (!argp2) {
82531     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
82532     return ;
82533   }
82534   arg2 = *argp2;
82535   {
82536     try {
82537       (arg1)->SetScrollingDirection(arg2);
82538     } catch (std::out_of_range& e) {
82539       {
82540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82541       };
82542     } catch (std::exception& e) {
82543       {
82544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82545       };
82546     } catch (Dali::DaliException e) {
82547       {
82548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82549       };
82550     } catch (...) {
82551       {
82552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82553       };
82554     }
82555   }
82556
82557 }
82558
82559
82560 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveScrollingDirection(void * jarg1, void * jarg2) {
82561   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82562   Dali::Radian arg2 ;
82563   Dali::Radian *argp2 ;
82564
82565   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82566   argp2 = (Dali::Radian *)jarg2;
82567   if (!argp2) {
82568     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
82569     return ;
82570   }
82571   arg2 = *argp2;
82572   {
82573     try {
82574       (arg1)->RemoveScrollingDirection(arg2);
82575     } catch (std::out_of_range& e) {
82576       {
82577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82578       };
82579     } catch (std::exception& e) {
82580       {
82581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82582       };
82583     } catch (Dali::DaliException e) {
82584       {
82585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82586       };
82587     } catch (...) {
82588       {
82589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82590       };
82591     }
82592   }
82593
82594 }
82595
82596
82597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapStartedSignal(void * jarg1) {
82598   void * jresult ;
82599   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82600   Dali::Toolkit::ScrollView::SnapStartedSignalType *result = 0 ;
82601
82602   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82603   {
82604     try {
82605       result = (Dali::Toolkit::ScrollView::SnapStartedSignalType *) &(arg1)->SnapStartedSignal();
82606     } catch (std::out_of_range& e) {
82607       {
82608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82609       };
82610     } catch (std::exception& e) {
82611       {
82612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82613       };
82614     } catch (Dali::DaliException e) {
82615       {
82616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82617       };
82618     } catch (...) {
82619       {
82620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82621       };
82622     }
82623   }
82624
82625   jresult = (void *)result;
82626   return jresult;
82627 }
82628
82629
82630 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_ROWS_get() {
82631   int jresult ;
82632   int result;
82633
82634   result = (int)Dali::Toolkit::TableView::Property::ROWS;
82635   jresult = (int)result;
82636   return jresult;
82637 }
82638
82639
82640 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_COLUMNS_get() {
82641   int jresult ;
82642   int result;
82643
82644   result = (int)Dali::Toolkit::TableView::Property::COLUMNS;
82645   jresult = (int)result;
82646   return jresult;
82647 }
82648
82649
82650 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_CELL_PADDING_get() {
82651   int jresult ;
82652   int result;
82653
82654   result = (int)Dali::Toolkit::TableView::Property::CELL_PADDING;
82655   jresult = (int)result;
82656   return jresult;
82657 }
82658
82659
82660 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_ROWS_get() {
82661   int jresult ;
82662   int result;
82663
82664   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_ROWS;
82665   jresult = (int)result;
82666   return jresult;
82667 }
82668
82669
82670 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_COLUMNS_get() {
82671   int jresult ;
82672   int result;
82673
82674   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_COLUMNS;
82675   jresult = (int)result;
82676   return jresult;
82677 }
82678
82679
82680 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_Property() {
82681   void * jresult ;
82682   Dali::Toolkit::TableView::Property *result = 0 ;
82683
82684   {
82685     try {
82686       result = (Dali::Toolkit::TableView::Property *)new Dali::Toolkit::TableView::Property();
82687     } catch (std::out_of_range& e) {
82688       {
82689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82690       };
82691     } catch (std::exception& e) {
82692       {
82693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82694       };
82695     } catch (Dali::DaliException e) {
82696       {
82697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82698       };
82699     } catch (...) {
82700       {
82701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82702       };
82703     }
82704   }
82705
82706   jresult = (void *)result;
82707   return jresult;
82708 }
82709
82710
82711 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_Property(void * jarg1) {
82712   Dali::Toolkit::TableView::Property *arg1 = (Dali::Toolkit::TableView::Property *) 0 ;
82713
82714   arg1 = (Dali::Toolkit::TableView::Property *)jarg1;
82715   {
82716     try {
82717       delete arg1;
82718     } catch (std::out_of_range& e) {
82719       {
82720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82721       };
82722     } catch (std::exception& e) {
82723       {
82724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82725       };
82726     } catch (Dali::DaliException e) {
82727       {
82728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82729       };
82730     } catch (...) {
82731       {
82732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82733       };
82734     }
82735   }
82736
82737 }
82738
82739
82740 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_INDEX_get() {
82741   int jresult ;
82742   int result;
82743
82744   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_INDEX;
82745   jresult = (int)result;
82746   return jresult;
82747 }
82748
82749
82750 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_ROW_SPAN_get() {
82751   int jresult ;
82752   int result;
82753
82754   result = (int)Dali::Toolkit::TableView::ChildProperty::ROW_SPAN;
82755   jresult = (int)result;
82756   return jresult;
82757 }
82758
82759
82760 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_COLUMN_SPAN_get() {
82761   int jresult ;
82762   int result;
82763
82764   result = (int)Dali::Toolkit::TableView::ChildProperty::COLUMN_SPAN;
82765   jresult = (int)result;
82766   return jresult;
82767 }
82768
82769
82770 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_HORIZONTAL_ALIGNMENT_get() {
82771   int jresult ;
82772   int result;
82773
82774   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_HORIZONTAL_ALIGNMENT;
82775   jresult = (int)result;
82776   return jresult;
82777 }
82778
82779
82780 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_VERTICAL_ALIGNMENT_get() {
82781   int jresult ;
82782   int result;
82783
82784   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_VERTICAL_ALIGNMENT;
82785   jresult = (int)result;
82786   return jresult;
82787 }
82788
82789
82790 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_ChildProperty() {
82791   void * jresult ;
82792   Dali::Toolkit::TableView::ChildProperty *result = 0 ;
82793
82794   {
82795     try {
82796       result = (Dali::Toolkit::TableView::ChildProperty *)new Dali::Toolkit::TableView::ChildProperty();
82797     } catch (std::out_of_range& e) {
82798       {
82799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82800       };
82801     } catch (std::exception& e) {
82802       {
82803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82804       };
82805     } catch (Dali::DaliException e) {
82806       {
82807         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82808       };
82809     } catch (...) {
82810       {
82811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82812       };
82813     }
82814   }
82815
82816   jresult = (void *)result;
82817   return jresult;
82818 }
82819
82820
82821 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_ChildProperty(void * jarg1) {
82822   Dali::Toolkit::TableView::ChildProperty *arg1 = (Dali::Toolkit::TableView::ChildProperty *) 0 ;
82823
82824   arg1 = (Dali::Toolkit::TableView::ChildProperty *)jarg1;
82825   {
82826     try {
82827       delete arg1;
82828     } catch (std::out_of_range& e) {
82829       {
82830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82831       };
82832     } catch (std::exception& e) {
82833       {
82834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82835       };
82836     } catch (Dali::DaliException e) {
82837       {
82838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82839       };
82840     } catch (...) {
82841       {
82842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82843       };
82844     }
82845   }
82846
82847 }
82848
82849
82850 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_0(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) {
82851   void * jresult ;
82852   unsigned int arg1 ;
82853   unsigned int arg2 ;
82854   unsigned int arg3 ;
82855   unsigned int arg4 ;
82856   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82857
82858   arg1 = (unsigned int)jarg1;
82859   arg2 = (unsigned int)jarg2;
82860   arg3 = (unsigned int)jarg3;
82861   arg4 = (unsigned int)jarg4;
82862   {
82863     try {
82864       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3,arg4);
82865     } catch (std::out_of_range& e) {
82866       {
82867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82868       };
82869     } catch (std::exception& e) {
82870       {
82871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82872       };
82873     } catch (Dali::DaliException e) {
82874       {
82875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82876       };
82877     } catch (...) {
82878       {
82879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82880       };
82881     }
82882   }
82883
82884   jresult = (void *)result;
82885   return jresult;
82886 }
82887
82888
82889 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_1(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
82890   void * jresult ;
82891   unsigned int arg1 ;
82892   unsigned int arg2 ;
82893   unsigned int arg3 ;
82894   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82895
82896   arg1 = (unsigned int)jarg1;
82897   arg2 = (unsigned int)jarg2;
82898   arg3 = (unsigned int)jarg3;
82899   {
82900     try {
82901       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3);
82902     } catch (std::out_of_range& e) {
82903       {
82904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82905       };
82906     } catch (std::exception& e) {
82907       {
82908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82909       };
82910     } catch (Dali::DaliException e) {
82911       {
82912         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82913       };
82914     } catch (...) {
82915       {
82916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82917       };
82918     }
82919   }
82920
82921   jresult = (void *)result;
82922   return jresult;
82923 }
82924
82925
82926 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
82927   void * jresult ;
82928   unsigned int arg1 ;
82929   unsigned int arg2 ;
82930   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82931
82932   arg1 = (unsigned int)jarg1;
82933   arg2 = (unsigned int)jarg2;
82934   {
82935     try {
82936       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2);
82937     } catch (std::out_of_range& e) {
82938       {
82939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82940       };
82941     } catch (std::exception& e) {
82942       {
82943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82944       };
82945     } catch (Dali::DaliException e) {
82946       {
82947         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82948       };
82949     } catch (...) {
82950       {
82951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82952       };
82953     }
82954   }
82955
82956   jresult = (void *)result;
82957   return jresult;
82958 }
82959
82960
82961 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_3(unsigned int jarg1) {
82962   void * jresult ;
82963   unsigned int arg1 ;
82964   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82965
82966   arg1 = (unsigned int)jarg1;
82967   {
82968     try {
82969       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1);
82970     } catch (std::out_of_range& e) {
82971       {
82972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82973       };
82974     } catch (std::exception& e) {
82975       {
82976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82977       };
82978     } catch (Dali::DaliException e) {
82979       {
82980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82981       };
82982     } catch (...) {
82983       {
82984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82985       };
82986     }
82987   }
82988
82989   jresult = (void *)result;
82990   return jresult;
82991 }
82992
82993
82994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_4() {
82995   void * jresult ;
82996   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82997
82998   {
82999     try {
83000       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition();
83001     } catch (std::out_of_range& e) {
83002       {
83003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83004       };
83005     } catch (std::exception& e) {
83006       {
83007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83008       };
83009     } catch (Dali::DaliException e) {
83010       {
83011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83012       };
83013     } catch (...) {
83014       {
83015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83016       };
83017     }
83018   }
83019
83020   jresult = (void *)result;
83021   return jresult;
83022 }
83023
83024
83025 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_set(void * jarg1, unsigned int jarg2) {
83026   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
83027   unsigned int arg2 ;
83028
83029   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
83030   arg2 = (unsigned int)jarg2;
83031   if (arg1) (arg1)->rowIndex = arg2;
83032 }
83033
83034
83035 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_get(void * jarg1) {
83036   unsigned int jresult ;
83037   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
83038   unsigned int result;
83039
83040   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
83041   result = (unsigned int) ((arg1)->rowIndex);
83042   jresult = result;
83043   return jresult;
83044 }
83045
83046
83047 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_set(void * jarg1, unsigned int jarg2) {
83048   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
83049   unsigned int arg2 ;
83050
83051   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
83052   arg2 = (unsigned int)jarg2;
83053   if (arg1) (arg1)->columnIndex = arg2;
83054 }
83055
83056
83057 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_get(void * jarg1) {
83058   unsigned int jresult ;
83059   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
83060   unsigned int result;
83061
83062   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
83063   result = (unsigned int) ((arg1)->columnIndex);
83064   jresult = result;
83065   return jresult;
83066 }
83067
83068
83069 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_set(void * jarg1, unsigned int jarg2) {
83070   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
83071   unsigned int arg2 ;
83072
83073   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
83074   arg2 = (unsigned int)jarg2;
83075   if (arg1) (arg1)->rowSpan = arg2;
83076 }
83077
83078
83079 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_get(void * jarg1) {
83080   unsigned int jresult ;
83081   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
83082   unsigned int result;
83083
83084   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
83085   result = (unsigned int) ((arg1)->rowSpan);
83086   jresult = result;
83087   return jresult;
83088 }
83089
83090
83091 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_set(void * jarg1, unsigned int jarg2) {
83092   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
83093   unsigned int arg2 ;
83094
83095   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
83096   arg2 = (unsigned int)jarg2;
83097   if (arg1) (arg1)->columnSpan = arg2;
83098 }
83099
83100
83101 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_get(void * jarg1) {
83102   unsigned int jresult ;
83103   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
83104   unsigned int result;
83105
83106   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
83107   result = (unsigned int) ((arg1)->columnSpan);
83108   jresult = result;
83109   return jresult;
83110 }
83111
83112
83113 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_CellPosition(void * jarg1) {
83114   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
83115
83116   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
83117   {
83118     try {
83119       delete arg1;
83120     } catch (std::out_of_range& e) {
83121       {
83122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83123       };
83124     } catch (std::exception& e) {
83125       {
83126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83127       };
83128     } catch (Dali::DaliException e) {
83129       {
83130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83131       };
83132     } catch (...) {
83133       {
83134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83135       };
83136     }
83137   }
83138
83139 }
83140
83141
83142 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_0() {
83143   void * jresult ;
83144   Dali::Toolkit::TableView *result = 0 ;
83145
83146   {
83147     try {
83148       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView();
83149     } catch (std::out_of_range& e) {
83150       {
83151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83152       };
83153     } catch (std::exception& e) {
83154       {
83155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83156       };
83157     } catch (Dali::DaliException e) {
83158       {
83159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83160       };
83161     } catch (...) {
83162       {
83163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83164       };
83165     }
83166   }
83167
83168   jresult = (void *)result;
83169   return jresult;
83170 }
83171
83172
83173 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_1(void * jarg1) {
83174   void * jresult ;
83175   Dali::Toolkit::TableView *arg1 = 0 ;
83176   Dali::Toolkit::TableView *result = 0 ;
83177
83178   arg1 = (Dali::Toolkit::TableView *)jarg1;
83179   if (!arg1) {
83180     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
83181     return 0;
83182   }
83183   {
83184     try {
83185       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView((Dali::Toolkit::TableView const &)*arg1);
83186     } catch (std::out_of_range& e) {
83187       {
83188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83189       };
83190     } catch (std::exception& e) {
83191       {
83192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83193       };
83194     } catch (Dali::DaliException e) {
83195       {
83196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83197       };
83198     } catch (...) {
83199       {
83200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83201       };
83202     }
83203   }
83204
83205   jresult = (void *)result;
83206   return jresult;
83207 }
83208
83209
83210 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_Assign(void * jarg1, void * jarg2) {
83211   void * jresult ;
83212   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83213   Dali::Toolkit::TableView *arg2 = 0 ;
83214   Dali::Toolkit::TableView *result = 0 ;
83215
83216   arg1 = (Dali::Toolkit::TableView *)jarg1;
83217   arg2 = (Dali::Toolkit::TableView *)jarg2;
83218   if (!arg2) {
83219     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
83220     return 0;
83221   }
83222   {
83223     try {
83224       result = (Dali::Toolkit::TableView *) &(arg1)->operator =((Dali::Toolkit::TableView const &)*arg2);
83225     } catch (std::out_of_range& e) {
83226       {
83227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83228       };
83229     } catch (std::exception& e) {
83230       {
83231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83232       };
83233     } catch (Dali::DaliException e) {
83234       {
83235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83236       };
83237     } catch (...) {
83238       {
83239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83240       };
83241     }
83242   }
83243
83244   jresult = (void *)result;
83245   return jresult;
83246 }
83247
83248
83249 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView(void * jarg1) {
83250   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83251
83252   arg1 = (Dali::Toolkit::TableView *)jarg1;
83253   {
83254     try {
83255       delete arg1;
83256     } catch (std::out_of_range& e) {
83257       {
83258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83259       };
83260     } catch (std::exception& e) {
83261       {
83262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83263       };
83264     } catch (Dali::DaliException e) {
83265       {
83266         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83267       };
83268     } catch (...) {
83269       {
83270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83271       };
83272     }
83273   }
83274
83275 }
83276
83277
83278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_New(unsigned int jarg1, unsigned int jarg2) {
83279   void * jresult ;
83280   unsigned int arg1 ;
83281   unsigned int arg2 ;
83282   Dali::Toolkit::TableView result;
83283
83284   arg1 = (unsigned int)jarg1;
83285   arg2 = (unsigned int)jarg2;
83286   {
83287     try {
83288       result = Dali::Toolkit::TableView::New(arg1,arg2);
83289     } catch (std::out_of_range& e) {
83290       {
83291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83292       };
83293     } catch (std::exception& e) {
83294       {
83295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83296       };
83297     } catch (Dali::DaliException e) {
83298       {
83299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83300       };
83301     } catch (...) {
83302       {
83303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83304       };
83305     }
83306   }
83307
83308   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
83309   return jresult;
83310 }
83311
83312
83313 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_DownCast(void * jarg1) {
83314   void * jresult ;
83315   Dali::BaseHandle arg1 ;
83316   Dali::BaseHandle *argp1 ;
83317   Dali::Toolkit::TableView result;
83318
83319   argp1 = (Dali::BaseHandle *)jarg1;
83320   if (!argp1) {
83321     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
83322     return 0;
83323   }
83324   arg1 = *argp1;
83325   {
83326     try {
83327       result = Dali::Toolkit::TableView::DownCast(arg1);
83328     } catch (std::out_of_range& e) {
83329       {
83330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83331       };
83332     } catch (std::exception& e) {
83333       {
83334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83335       };
83336     } catch (Dali::DaliException e) {
83337       {
83338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83339       };
83340     } catch (...) {
83341       {
83342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83343       };
83344     }
83345   }
83346
83347   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
83348   return jresult;
83349 }
83350
83351
83352 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_AddChild(void * jarg1, void * jarg2, void * jarg3) {
83353   unsigned int jresult ;
83354   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83355   Dali::Actor arg2 ;
83356   Dali::Toolkit::TableView::CellPosition arg3 ;
83357   Dali::Actor *argp2 ;
83358   Dali::Toolkit::TableView::CellPosition *argp3 ;
83359   bool result;
83360
83361   arg1 = (Dali::Toolkit::TableView *)jarg1;
83362   argp2 = (Dali::Actor *)jarg2;
83363   if (!argp2) {
83364     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83365     return 0;
83366   }
83367   arg2 = *argp2;
83368   argp3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
83369   if (!argp3) {
83370     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
83371     return 0;
83372   }
83373   arg3 = *argp3;
83374   {
83375     try {
83376       result = (bool)(arg1)->AddChild(arg2,arg3);
83377     } catch (std::out_of_range& e) {
83378       {
83379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83380       };
83381     } catch (std::exception& e) {
83382       {
83383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83384       };
83385     } catch (Dali::DaliException e) {
83386       {
83387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83388       };
83389     } catch (...) {
83390       {
83391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83392       };
83393     }
83394   }
83395
83396   jresult = result;
83397   return jresult;
83398 }
83399
83400
83401 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetChildAt(void * jarg1, void * jarg2) {
83402   void * jresult ;
83403   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83404   Dali::Toolkit::TableView::CellPosition arg2 ;
83405   Dali::Toolkit::TableView::CellPosition *argp2 ;
83406   Dali::Actor result;
83407
83408   arg1 = (Dali::Toolkit::TableView *)jarg1;
83409   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
83410   if (!argp2) {
83411     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
83412     return 0;
83413   }
83414   arg2 = *argp2;
83415   {
83416     try {
83417       result = (arg1)->GetChildAt(arg2);
83418     } catch (std::out_of_range& e) {
83419       {
83420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83421       };
83422     } catch (std::exception& e) {
83423       {
83424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83425       };
83426     } catch (Dali::DaliException e) {
83427       {
83428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83429       };
83430     } catch (...) {
83431       {
83432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83433       };
83434     }
83435   }
83436
83437   jresult = new Dali::Actor((const Dali::Actor &)result);
83438   return jresult;
83439 }
83440
83441
83442 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_RemoveChildAt(void * jarg1, void * jarg2) {
83443   void * jresult ;
83444   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83445   Dali::Toolkit::TableView::CellPosition arg2 ;
83446   Dali::Toolkit::TableView::CellPosition *argp2 ;
83447   Dali::Actor result;
83448
83449   arg1 = (Dali::Toolkit::TableView *)jarg1;
83450   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
83451   if (!argp2) {
83452     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
83453     return 0;
83454   }
83455   arg2 = *argp2;
83456   {
83457     try {
83458       result = (arg1)->RemoveChildAt(arg2);
83459     } catch (std::out_of_range& e) {
83460       {
83461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83462       };
83463     } catch (std::exception& e) {
83464       {
83465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83466       };
83467     } catch (Dali::DaliException e) {
83468       {
83469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83470       };
83471     } catch (...) {
83472       {
83473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83474       };
83475     }
83476   }
83477
83478   jresult = new Dali::Actor((const Dali::Actor &)result);
83479   return jresult;
83480 }
83481
83482
83483 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_FindChildPosition(void * jarg1, void * jarg2, void * jarg3) {
83484   unsigned int jresult ;
83485   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83486   Dali::Actor arg2 ;
83487   Dali::Toolkit::TableView::CellPosition *arg3 = 0 ;
83488   Dali::Actor *argp2 ;
83489   bool result;
83490
83491   arg1 = (Dali::Toolkit::TableView *)jarg1;
83492   argp2 = (Dali::Actor *)jarg2;
83493   if (!argp2) {
83494     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83495     return 0;
83496   }
83497   arg2 = *argp2;
83498   arg3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
83499   if (!arg3) {
83500     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView::CellPosition & type is null", 0);
83501     return 0;
83502   }
83503   {
83504     try {
83505       result = (bool)(arg1)->FindChildPosition(arg2,*arg3);
83506     } catch (std::out_of_range& e) {
83507       {
83508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83509       };
83510     } catch (std::exception& e) {
83511       {
83512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83513       };
83514     } catch (Dali::DaliException e) {
83515       {
83516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83517       };
83518     } catch (...) {
83519       {
83520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83521       };
83522     }
83523   }
83524
83525   jresult = result;
83526   return jresult;
83527 }
83528
83529
83530 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertRow(void * jarg1, unsigned int jarg2) {
83531   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83532   unsigned int arg2 ;
83533
83534   arg1 = (Dali::Toolkit::TableView *)jarg1;
83535   arg2 = (unsigned int)jarg2;
83536   {
83537     try {
83538       (arg1)->InsertRow(arg2);
83539     } catch (std::out_of_range& e) {
83540       {
83541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83542       };
83543     } catch (std::exception& e) {
83544       {
83545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83546       };
83547     } catch (Dali::DaliException e) {
83548       {
83549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83550       };
83551     } catch (...) {
83552       {
83553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83554       };
83555     }
83556   }
83557
83558 }
83559
83560
83561 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_0(void * jarg1, unsigned int jarg2) {
83562   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83563   unsigned int arg2 ;
83564
83565   arg1 = (Dali::Toolkit::TableView *)jarg1;
83566   arg2 = (unsigned int)jarg2;
83567   {
83568     try {
83569       (arg1)->DeleteRow(arg2);
83570     } catch (std::out_of_range& e) {
83571       {
83572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83573       };
83574     } catch (std::exception& e) {
83575       {
83576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83577       };
83578     } catch (Dali::DaliException e) {
83579       {
83580         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83581       };
83582     } catch (...) {
83583       {
83584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83585       };
83586     }
83587   }
83588
83589 }
83590
83591
83592 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
83593   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83594   unsigned int arg2 ;
83595   std::vector< Dali::Actor > *arg3 = 0 ;
83596
83597   arg1 = (Dali::Toolkit::TableView *)jarg1;
83598   arg2 = (unsigned int)jarg2;
83599   arg3 = (std::vector< Dali::Actor > *)jarg3;
83600   if (!arg3) {
83601     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
83602     return ;
83603   }
83604   {
83605     try {
83606       (arg1)->DeleteRow(arg2,*arg3);
83607     } catch (std::out_of_range& e) {
83608       {
83609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83610       };
83611     } catch (std::exception& e) {
83612       {
83613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83614       };
83615     } catch (Dali::DaliException e) {
83616       {
83617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83618       };
83619     } catch (...) {
83620       {
83621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83622       };
83623     }
83624   }
83625
83626 }
83627
83628
83629 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertColumn(void * jarg1, unsigned int jarg2) {
83630   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83631   unsigned int arg2 ;
83632
83633   arg1 = (Dali::Toolkit::TableView *)jarg1;
83634   arg2 = (unsigned int)jarg2;
83635   {
83636     try {
83637       (arg1)->InsertColumn(arg2);
83638     } catch (std::out_of_range& e) {
83639       {
83640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83641       };
83642     } catch (std::exception& e) {
83643       {
83644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83645       };
83646     } catch (Dali::DaliException e) {
83647       {
83648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83649       };
83650     } catch (...) {
83651       {
83652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83653       };
83654     }
83655   }
83656
83657 }
83658
83659
83660 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_0(void * jarg1, unsigned int jarg2) {
83661   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83662   unsigned int arg2 ;
83663
83664   arg1 = (Dali::Toolkit::TableView *)jarg1;
83665   arg2 = (unsigned int)jarg2;
83666   {
83667     try {
83668       (arg1)->DeleteColumn(arg2);
83669     } catch (std::out_of_range& e) {
83670       {
83671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83672       };
83673     } catch (std::exception& e) {
83674       {
83675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83676       };
83677     } catch (Dali::DaliException e) {
83678       {
83679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83680       };
83681     } catch (...) {
83682       {
83683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83684       };
83685     }
83686   }
83687
83688 }
83689
83690
83691 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
83692   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83693   unsigned int arg2 ;
83694   std::vector< Dali::Actor > *arg3 = 0 ;
83695
83696   arg1 = (Dali::Toolkit::TableView *)jarg1;
83697   arg2 = (unsigned int)jarg2;
83698   arg3 = (std::vector< Dali::Actor > *)jarg3;
83699   if (!arg3) {
83700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
83701     return ;
83702   }
83703   {
83704     try {
83705       (arg1)->DeleteColumn(arg2,*arg3);
83706     } catch (std::out_of_range& e) {
83707       {
83708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83709       };
83710     } catch (std::exception& e) {
83711       {
83712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83713       };
83714     } catch (Dali::DaliException e) {
83715       {
83716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83717       };
83718     } catch (...) {
83719       {
83720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83721       };
83722     }
83723   }
83724
83725 }
83726
83727
83728 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
83729   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83730   unsigned int arg2 ;
83731   unsigned int arg3 ;
83732
83733   arg1 = (Dali::Toolkit::TableView *)jarg1;
83734   arg2 = (unsigned int)jarg2;
83735   arg3 = (unsigned int)jarg3;
83736   {
83737     try {
83738       (arg1)->Resize(arg2,arg3);
83739     } catch (std::out_of_range& e) {
83740       {
83741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83742       };
83743     } catch (std::exception& e) {
83744       {
83745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83746       };
83747     } catch (Dali::DaliException e) {
83748       {
83749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83750       };
83751     } catch (...) {
83752       {
83753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83754       };
83755     }
83756   }
83757
83758 }
83759
83760
83761 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4) {
83762   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83763   unsigned int arg2 ;
83764   unsigned int arg3 ;
83765   std::vector< Dali::Actor > *arg4 = 0 ;
83766
83767   arg1 = (Dali::Toolkit::TableView *)jarg1;
83768   arg2 = (unsigned int)jarg2;
83769   arg3 = (unsigned int)jarg3;
83770   arg4 = (std::vector< Dali::Actor > *)jarg4;
83771   if (!arg4) {
83772     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
83773     return ;
83774   }
83775   {
83776     try {
83777       (arg1)->Resize(arg2,arg3,*arg4);
83778     } catch (std::out_of_range& e) {
83779       {
83780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83781       };
83782     } catch (std::exception& e) {
83783       {
83784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83785       };
83786     } catch (Dali::DaliException e) {
83787       {
83788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83789       };
83790     } catch (...) {
83791       {
83792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83793       };
83794     }
83795   }
83796
83797 }
83798
83799
83800 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellPadding(void * jarg1, void * jarg2) {
83801   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83802   Dali::Size arg2 ;
83803   Dali::Size *argp2 ;
83804
83805   arg1 = (Dali::Toolkit::TableView *)jarg1;
83806   argp2 = (Dali::Size *)jarg2;
83807   if (!argp2) {
83808     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
83809     return ;
83810   }
83811   arg2 = *argp2;
83812   {
83813     try {
83814       (arg1)->SetCellPadding(arg2);
83815     } catch (std::out_of_range& e) {
83816       {
83817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83818       };
83819     } catch (std::exception& e) {
83820       {
83821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83822       };
83823     } catch (Dali::DaliException e) {
83824       {
83825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83826       };
83827     } catch (...) {
83828       {
83829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83830       };
83831     }
83832   }
83833
83834 }
83835
83836
83837 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetCellPadding(void * jarg1) {
83838   void * jresult ;
83839   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83840   Dali::Size result;
83841
83842   arg1 = (Dali::Toolkit::TableView *)jarg1;
83843   {
83844     try {
83845       result = (arg1)->GetCellPadding();
83846     } catch (std::out_of_range& e) {
83847       {
83848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83849       };
83850     } catch (std::exception& e) {
83851       {
83852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83853       };
83854     } catch (Dali::DaliException e) {
83855       {
83856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83857       };
83858     } catch (...) {
83859       {
83860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83861       };
83862     }
83863   }
83864
83865   jresult = new Dali::Size((const Dali::Size &)result);
83866   return jresult;
83867 }
83868
83869
83870 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitHeight(void * jarg1, unsigned int jarg2) {
83871   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83872   unsigned int arg2 ;
83873
83874   arg1 = (Dali::Toolkit::TableView *)jarg1;
83875   arg2 = (unsigned int)jarg2;
83876   {
83877     try {
83878       (arg1)->SetFitHeight(arg2);
83879     } catch (std::out_of_range& e) {
83880       {
83881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83882       };
83883     } catch (std::exception& e) {
83884       {
83885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83886       };
83887     } catch (Dali::DaliException e) {
83888       {
83889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83890       };
83891     } catch (...) {
83892       {
83893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83894       };
83895     }
83896   }
83897
83898 }
83899
83900
83901 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitHeight(void * jarg1, unsigned int jarg2) {
83902   unsigned int jresult ;
83903   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83904   unsigned int arg2 ;
83905   bool result;
83906
83907   arg1 = (Dali::Toolkit::TableView *)jarg1;
83908   arg2 = (unsigned int)jarg2;
83909   {
83910     try {
83911       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitHeight(arg2);
83912     } catch (std::out_of_range& e) {
83913       {
83914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83915       };
83916     } catch (std::exception& e) {
83917       {
83918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83919       };
83920     } catch (Dali::DaliException e) {
83921       {
83922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83923       };
83924     } catch (...) {
83925       {
83926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83927       };
83928     }
83929   }
83930
83931   jresult = result;
83932   return jresult;
83933 }
83934
83935
83936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitWidth(void * jarg1, unsigned int jarg2) {
83937   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83938   unsigned int arg2 ;
83939
83940   arg1 = (Dali::Toolkit::TableView *)jarg1;
83941   arg2 = (unsigned int)jarg2;
83942   {
83943     try {
83944       (arg1)->SetFitWidth(arg2);
83945     } catch (std::out_of_range& e) {
83946       {
83947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83948       };
83949     } catch (std::exception& e) {
83950       {
83951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83952       };
83953     } catch (Dali::DaliException e) {
83954       {
83955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83956       };
83957     } catch (...) {
83958       {
83959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83960       };
83961     }
83962   }
83963
83964 }
83965
83966
83967 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitWidth(void * jarg1, unsigned int jarg2) {
83968   unsigned int jresult ;
83969   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83970   unsigned int arg2 ;
83971   bool result;
83972
83973   arg1 = (Dali::Toolkit::TableView *)jarg1;
83974   arg2 = (unsigned int)jarg2;
83975   {
83976     try {
83977       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitWidth(arg2);
83978     } catch (std::out_of_range& e) {
83979       {
83980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83981       };
83982     } catch (std::exception& e) {
83983       {
83984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83985       };
83986     } catch (Dali::DaliException e) {
83987       {
83988         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83989       };
83990     } catch (...) {
83991       {
83992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83993       };
83994     }
83995   }
83996
83997   jresult = result;
83998   return jresult;
83999 }
84000
84001
84002 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedHeight(void * jarg1, unsigned int jarg2, float jarg3) {
84003   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
84004   unsigned int arg2 ;
84005   float arg3 ;
84006
84007   arg1 = (Dali::Toolkit::TableView *)jarg1;
84008   arg2 = (unsigned int)jarg2;
84009   arg3 = (float)jarg3;
84010   {
84011     try {
84012       (arg1)->SetFixedHeight(arg2,arg3);
84013     } catch (std::out_of_range& e) {
84014       {
84015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84016       };
84017     } catch (std::exception& e) {
84018       {
84019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84020       };
84021     } catch (Dali::DaliException e) {
84022       {
84023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84024       };
84025     } catch (...) {
84026       {
84027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84028       };
84029     }
84030   }
84031
84032 }
84033
84034
84035 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedHeight(void * jarg1, unsigned int jarg2) {
84036   float jresult ;
84037   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
84038   unsigned int arg2 ;
84039   float result;
84040
84041   arg1 = (Dali::Toolkit::TableView *)jarg1;
84042   arg2 = (unsigned int)jarg2;
84043   {
84044     try {
84045       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedHeight(arg2);
84046     } catch (std::out_of_range& e) {
84047       {
84048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84049       };
84050     } catch (std::exception& e) {
84051       {
84052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84053       };
84054     } catch (Dali::DaliException e) {
84055       {
84056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84057       };
84058     } catch (...) {
84059       {
84060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84061       };
84062     }
84063   }
84064
84065   jresult = result;
84066   return jresult;
84067 }
84068
84069
84070 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeHeight(void * jarg1, unsigned int jarg2, float jarg3) {
84071   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
84072   unsigned int arg2 ;
84073   float arg3 ;
84074
84075   arg1 = (Dali::Toolkit::TableView *)jarg1;
84076   arg2 = (unsigned int)jarg2;
84077   arg3 = (float)jarg3;
84078   {
84079     try {
84080       (arg1)->SetRelativeHeight(arg2,arg3);
84081     } catch (std::out_of_range& e) {
84082       {
84083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84084       };
84085     } catch (std::exception& e) {
84086       {
84087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84088       };
84089     } catch (Dali::DaliException e) {
84090       {
84091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84092       };
84093     } catch (...) {
84094       {
84095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84096       };
84097     }
84098   }
84099
84100 }
84101
84102
84103 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeHeight(void * jarg1, unsigned int jarg2) {
84104   float jresult ;
84105   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
84106   unsigned int arg2 ;
84107   float result;
84108
84109   arg1 = (Dali::Toolkit::TableView *)jarg1;
84110   arg2 = (unsigned int)jarg2;
84111   {
84112     try {
84113       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeHeight(arg2);
84114     } catch (std::out_of_range& e) {
84115       {
84116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84117       };
84118     } catch (std::exception& e) {
84119       {
84120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84121       };
84122     } catch (Dali::DaliException e) {
84123       {
84124         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84125       };
84126     } catch (...) {
84127       {
84128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84129       };
84130     }
84131   }
84132
84133   jresult = result;
84134   return jresult;
84135 }
84136
84137
84138 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedWidth(void * jarg1, unsigned int jarg2, float jarg3) {
84139   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
84140   unsigned int arg2 ;
84141   float arg3 ;
84142
84143   arg1 = (Dali::Toolkit::TableView *)jarg1;
84144   arg2 = (unsigned int)jarg2;
84145   arg3 = (float)jarg3;
84146   {
84147     try {
84148       (arg1)->SetFixedWidth(arg2,arg3);
84149     } catch (std::out_of_range& e) {
84150       {
84151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84152       };
84153     } catch (std::exception& e) {
84154       {
84155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84156       };
84157     } catch (Dali::DaliException e) {
84158       {
84159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84160       };
84161     } catch (...) {
84162       {
84163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84164       };
84165     }
84166   }
84167
84168 }
84169
84170
84171 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedWidth(void * jarg1, unsigned int jarg2) {
84172   float jresult ;
84173   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
84174   unsigned int arg2 ;
84175   float result;
84176
84177   arg1 = (Dali::Toolkit::TableView *)jarg1;
84178   arg2 = (unsigned int)jarg2;
84179   {
84180     try {
84181       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedWidth(arg2);
84182     } catch (std::out_of_range& e) {
84183       {
84184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84185       };
84186     } catch (std::exception& e) {
84187       {
84188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84189       };
84190     } catch (Dali::DaliException e) {
84191       {
84192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84193       };
84194     } catch (...) {
84195       {
84196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84197       };
84198     }
84199   }
84200
84201   jresult = result;
84202   return jresult;
84203 }
84204
84205
84206 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeWidth(void * jarg1, unsigned int jarg2, float jarg3) {
84207   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
84208   unsigned int arg2 ;
84209   float arg3 ;
84210
84211   arg1 = (Dali::Toolkit::TableView *)jarg1;
84212   arg2 = (unsigned int)jarg2;
84213   arg3 = (float)jarg3;
84214   {
84215     try {
84216       (arg1)->SetRelativeWidth(arg2,arg3);
84217     } catch (std::out_of_range& e) {
84218       {
84219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84220       };
84221     } catch (std::exception& e) {
84222       {
84223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84224       };
84225     } catch (Dali::DaliException e) {
84226       {
84227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84228       };
84229     } catch (...) {
84230       {
84231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84232       };
84233     }
84234   }
84235
84236 }
84237
84238
84239 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeWidth(void * jarg1, unsigned int jarg2) {
84240   float jresult ;
84241   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
84242   unsigned int arg2 ;
84243   float result;
84244
84245   arg1 = (Dali::Toolkit::TableView *)jarg1;
84246   arg2 = (unsigned int)jarg2;
84247   {
84248     try {
84249       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeWidth(arg2);
84250     } catch (std::out_of_range& e) {
84251       {
84252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84253       };
84254     } catch (std::exception& e) {
84255       {
84256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84257       };
84258     } catch (Dali::DaliException e) {
84259       {
84260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84261       };
84262     } catch (...) {
84263       {
84264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84265       };
84266     }
84267   }
84268
84269   jresult = result;
84270   return jresult;
84271 }
84272
84273
84274 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetRows(void * jarg1) {
84275   unsigned int jresult ;
84276   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
84277   unsigned int result;
84278
84279   arg1 = (Dali::Toolkit::TableView *)jarg1;
84280   {
84281     try {
84282       result = (unsigned int)(arg1)->GetRows();
84283     } catch (std::out_of_range& e) {
84284       {
84285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84286       };
84287     } catch (std::exception& e) {
84288       {
84289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84290       };
84291     } catch (Dali::DaliException e) {
84292       {
84293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84294       };
84295     } catch (...) {
84296       {
84297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84298       };
84299     }
84300   }
84301
84302   jresult = result;
84303   return jresult;
84304 }
84305
84306
84307 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetColumns(void * jarg1) {
84308   unsigned int jresult ;
84309   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
84310   unsigned int result;
84311
84312   arg1 = (Dali::Toolkit::TableView *)jarg1;
84313   {
84314     try {
84315       result = (unsigned int)(arg1)->GetColumns();
84316     } catch (std::out_of_range& e) {
84317       {
84318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84319       };
84320     } catch (std::exception& e) {
84321       {
84322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84323       };
84324     } catch (Dali::DaliException e) {
84325       {
84326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84327       };
84328     } catch (...) {
84329       {
84330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84331       };
84332     }
84333   }
84334
84335   jresult = result;
84336   return jresult;
84337 }
84338
84339
84340 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellAlignment(void * jarg1, void * jarg2, int jarg3, int jarg4) {
84341   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
84342   Dali::Toolkit::TableView::CellPosition arg2 ;
84343   Dali::HorizontalAlignment::Type arg3 ;
84344   Dali::VerticalAlignment::Type arg4 ;
84345   Dali::Toolkit::TableView::CellPosition *argp2 ;
84346
84347   arg1 = (Dali::Toolkit::TableView *)jarg1;
84348   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
84349   if (!argp2) {
84350     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
84351     return ;
84352   }
84353   arg2 = *argp2;
84354   arg3 = (Dali::HorizontalAlignment::Type)jarg3;
84355   arg4 = (Dali::VerticalAlignment::Type)jarg4;
84356   {
84357     try {
84358       (arg1)->SetCellAlignment(arg2,arg3,arg4);
84359     } catch (std::out_of_range& e) {
84360       {
84361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84362       };
84363     } catch (std::exception& e) {
84364       {
84365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84366       };
84367     } catch (Dali::DaliException e) {
84368       {
84369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84370       };
84371     } catch (...) {
84372       {
84373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84374       };
84375     }
84376   }
84377
84378 }
84379
84380
84381 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DEFAULT_RENDERING_BACKEND_get() {
84382   unsigned int jresult ;
84383   unsigned int result;
84384
84385   result = (unsigned int)(unsigned int)Dali::Toolkit::Text::DEFAULT_RENDERING_BACKEND;
84386   jresult = result;
84387   return jresult;
84388 }
84389
84390
84391 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_RENDERING_BACKEND_get() {
84392   int jresult ;
84393   int result;
84394
84395   result = (int)Dali::Toolkit::TextLabel::Property::RENDERING_BACKEND;
84396   jresult = (int)result;
84397   return jresult;
84398 }
84399
84400
84401 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_get() {
84402   int jresult ;
84403   int result;
84404
84405   result = (int)Dali::Toolkit::TextLabel::Property::TEXT;
84406   jresult = (int)result;
84407   return jresult;
84408 }
84409
84410
84411 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_FAMILY_get() {
84412   int jresult ;
84413   int result;
84414
84415   result = (int)Dali::Toolkit::TextLabel::Property::FONT_FAMILY;
84416   jresult = (int)result;
84417   return jresult;
84418 }
84419
84420
84421 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_STYLE_get() {
84422   int jresult ;
84423   int result;
84424
84425   result = (int)Dali::Toolkit::TextLabel::Property::FONT_STYLE;
84426   jresult = (int)result;
84427   return jresult;
84428 }
84429
84430
84431 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_POINT_SIZE_get() {
84432   int jresult ;
84433   int result;
84434
84435   result = (int)Dali::Toolkit::TextLabel::Property::POINT_SIZE;
84436   jresult = (int)result;
84437   return jresult;
84438 }
84439
84440
84441 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_MULTI_LINE_get() {
84442   int jresult ;
84443   int result;
84444
84445   result = (int)Dali::Toolkit::TextLabel::Property::MULTI_LINE;
84446   jresult = (int)result;
84447   return jresult;
84448 }
84449
84450
84451 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_HORIZONTAL_ALIGNMENT_get() {
84452   int jresult ;
84453   int result;
84454
84455   result = (int)Dali::Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT;
84456   jresult = (int)result;
84457   return jresult;
84458 }
84459
84460
84461 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_VERTICAL_ALIGNMENT_get() {
84462   int jresult ;
84463   int result;
84464
84465   result = (int)Dali::Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT;
84466   jresult = (int)result;
84467   return jresult;
84468 }
84469
84470
84471 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_COLOR_get() {
84472   int jresult ;
84473   int result;
84474
84475   result = (int)Dali::Toolkit::TextLabel::Property::TEXT_COLOR;
84476   jresult = (int)result;
84477   return jresult;
84478 }
84479
84480 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_OFFSET_get() {
84481   int jresult ;
84482   int result;
84483
84484   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW_OFFSET;
84485   jresult = (int)result;
84486   return jresult;
84487 }
84488
84489
84490 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_COLOR_get() {
84491   int jresult ;
84492   int result;
84493
84494   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW_COLOR;
84495   jresult = (int)result;
84496   return jresult;
84497 }
84498
84499
84500 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_ENABLED_get() {
84501   int jresult ;
84502   int result;
84503
84504   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_ENABLED;
84505   jresult = (int)result;
84506   return jresult;
84507 }
84508
84509
84510 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_COLOR_get() {
84511   int jresult ;
84512   int result;
84513
84514   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_COLOR;
84515   jresult = (int)result;
84516   return jresult;
84517 }
84518
84519
84520 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_HEIGHT_get() {
84521   int jresult ;
84522   int result;
84523
84524   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_HEIGHT;
84525   jresult = (int)result;
84526   return jresult;
84527 }
84528
84529
84530 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_MARKUP_get() {
84531   int jresult ;
84532   int result;
84533
84534   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_MARKUP;
84535   jresult = (int)result;
84536   return jresult;
84537 }
84538
84539
84540 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_AUTO_SCROLL_get() {
84541   int jresult ;
84542   int result;
84543
84544   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_AUTO_SCROLL;
84545   jresult = (int)result;
84546   return jresult;
84547 }
84548
84549
84550 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_SPEED_get() {
84551   int jresult ;
84552   int result;
84553
84554   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_SPEED;
84555   jresult = (int)result;
84556   return jresult;
84557 }
84558
84559
84560 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_LOOP_COUNT_get() {
84561   int jresult ;
84562   int result;
84563
84564   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_LOOP_COUNT;
84565   jresult = (int)result;
84566   return jresult;
84567 }
84568
84569
84570 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_GAP_get() {
84571   int jresult ;
84572   int result;
84573
84574   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_GAP;
84575   jresult = (int)result;
84576   return jresult;
84577 }
84578
84579
84580 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_LINE_SPACING_get() {
84581   int jresult ;
84582   int result;
84583
84584   result = (int)Dali::Toolkit::TextLabel::Property::LINE_SPACING;
84585   jresult = (int)result;
84586   return jresult;
84587 }
84588
84589
84590 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_get() {
84591   int jresult ;
84592   int result;
84593
84594   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE;
84595   jresult = (int)result;
84596   return jresult;
84597 }
84598
84599
84600 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_get() {
84601   int jresult ;
84602   int result;
84603
84604   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW;
84605   jresult = (int)result;
84606   return jresult;
84607 }
84608
84609
84610 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_EMBOSS_get() {
84611   int jresult ;
84612   int result;
84613
84614   result = (int)Dali::Toolkit::TextLabel::Property::EMBOSS;
84615   jresult = (int)result;
84616   return jresult;
84617 }
84618
84619
84620 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_OUTLINE_get() {
84621   int jresult ;
84622   int result;
84623
84624   result = (int)Dali::Toolkit::TextLabel::Property::OUTLINE;
84625   jresult = (int)result;
84626   return jresult;
84627 }
84628
84629
84630 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel_Property() {
84631   void * jresult ;
84632   Dali::Toolkit::TextLabel::Property *result = 0 ;
84633
84634   {
84635     try {
84636       result = (Dali::Toolkit::TextLabel::Property *)new Dali::Toolkit::TextLabel::Property();
84637     } catch (std::out_of_range& e) {
84638       {
84639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84640       };
84641     } catch (std::exception& e) {
84642       {
84643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84644       };
84645     } catch (Dali::DaliException e) {
84646       {
84647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84648       };
84649     } catch (...) {
84650       {
84651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84652       };
84653     }
84654   }
84655
84656   jresult = (void *)result;
84657   return jresult;
84658 }
84659
84660
84661 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel_Property(void * jarg1) {
84662   Dali::Toolkit::TextLabel::Property *arg1 = (Dali::Toolkit::TextLabel::Property *) 0 ;
84663
84664   arg1 = (Dali::Toolkit::TextLabel::Property *)jarg1;
84665   {
84666     try {
84667       delete arg1;
84668     } catch (std::out_of_range& e) {
84669       {
84670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84671       };
84672     } catch (std::exception& e) {
84673       {
84674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84675       };
84676     } catch (Dali::DaliException e) {
84677       {
84678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84679       };
84680     } catch (...) {
84681       {
84682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84683       };
84684     }
84685   }
84686
84687 }
84688
84689
84690 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_0() {
84691   void * jresult ;
84692   Dali::Toolkit::TextLabel result;
84693
84694   {
84695     try {
84696       result = Dali::Toolkit::TextLabel::New();
84697     } catch (std::out_of_range& e) {
84698       {
84699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84700       };
84701     } catch (std::exception& e) {
84702       {
84703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84704       };
84705     } catch (Dali::DaliException e) {
84706       {
84707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84708       };
84709     } catch (...) {
84710       {
84711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84712       };
84713     }
84714   }
84715
84716   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
84717   return jresult;
84718 }
84719
84720
84721 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_1(char * jarg1) {
84722   void * jresult ;
84723   std::string *arg1 = 0 ;
84724   Dali::Toolkit::TextLabel result;
84725
84726   if (!jarg1) {
84727     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
84728     return 0;
84729   }
84730   std::string arg1_str(jarg1);
84731   arg1 = &arg1_str;
84732   {
84733     try {
84734       result = Dali::Toolkit::TextLabel::New((std::string const &)*arg1);
84735     } catch (std::out_of_range& e) {
84736       {
84737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84738       };
84739     } catch (std::exception& e) {
84740       {
84741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84742       };
84743     } catch (Dali::DaliException e) {
84744       {
84745         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84746       };
84747     } catch (...) {
84748       {
84749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84750       };
84751     }
84752   }
84753
84754   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
84755
84756   //argout typemap for const std::string&
84757
84758   return jresult;
84759 }
84760
84761
84762 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_0() {
84763   void * jresult ;
84764   Dali::Toolkit::TextLabel *result = 0 ;
84765
84766   {
84767     try {
84768       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel();
84769     } catch (std::out_of_range& e) {
84770       {
84771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84772       };
84773     } catch (std::exception& e) {
84774       {
84775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84776       };
84777     } catch (Dali::DaliException e) {
84778       {
84779         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84780       };
84781     } catch (...) {
84782       {
84783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84784       };
84785     }
84786   }
84787
84788   jresult = (void *)result;
84789   return jresult;
84790 }
84791
84792
84793 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_1(void * jarg1) {
84794   void * jresult ;
84795   Dali::Toolkit::TextLabel *arg1 = 0 ;
84796   Dali::Toolkit::TextLabel *result = 0 ;
84797
84798   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
84799   if (!arg1) {
84800     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
84801     return 0;
84802   }
84803   {
84804     try {
84805       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel((Dali::Toolkit::TextLabel const &)*arg1);
84806     } catch (std::out_of_range& e) {
84807       {
84808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84809       };
84810     } catch (std::exception& e) {
84811       {
84812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84813       };
84814     } catch (Dali::DaliException e) {
84815       {
84816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84817       };
84818     } catch (...) {
84819       {
84820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84821       };
84822     }
84823   }
84824
84825   jresult = (void *)result;
84826   return jresult;
84827 }
84828
84829
84830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_Assign(void * jarg1, void * jarg2) {
84831   void * jresult ;
84832   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
84833   Dali::Toolkit::TextLabel *arg2 = 0 ;
84834   Dali::Toolkit::TextLabel *result = 0 ;
84835
84836   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
84837   arg2 = (Dali::Toolkit::TextLabel *)jarg2;
84838   if (!arg2) {
84839     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
84840     return 0;
84841   }
84842   {
84843     try {
84844       result = (Dali::Toolkit::TextLabel *) &(arg1)->operator =((Dali::Toolkit::TextLabel const &)*arg2);
84845     } catch (std::out_of_range& e) {
84846       {
84847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84848       };
84849     } catch (std::exception& e) {
84850       {
84851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84852       };
84853     } catch (Dali::DaliException e) {
84854       {
84855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84856       };
84857     } catch (...) {
84858       {
84859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84860       };
84861     }
84862   }
84863
84864   jresult = (void *)result;
84865   return jresult;
84866 }
84867
84868
84869 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel(void * jarg1) {
84870   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
84871
84872   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
84873   {
84874     try {
84875       delete arg1;
84876     } catch (std::out_of_range& e) {
84877       {
84878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84879       };
84880     } catch (std::exception& e) {
84881       {
84882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84883       };
84884     } catch (Dali::DaliException e) {
84885       {
84886         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84887       };
84888     } catch (...) {
84889       {
84890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84891       };
84892     }
84893   }
84894
84895 }
84896
84897
84898 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_DownCast(void * jarg1) {
84899   void * jresult ;
84900   Dali::BaseHandle arg1 ;
84901   Dali::BaseHandle *argp1 ;
84902   Dali::Toolkit::TextLabel result;
84903
84904   argp1 = (Dali::BaseHandle *)jarg1;
84905   if (!argp1) {
84906     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
84907     return 0;
84908   }
84909   arg1 = *argp1;
84910   {
84911     try {
84912       result = Dali::Toolkit::TextLabel::DownCast(arg1);
84913     } catch (std::out_of_range& e) {
84914       {
84915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84916       };
84917     } catch (std::exception& e) {
84918       {
84919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84920       };
84921     } catch (Dali::DaliException e) {
84922       {
84923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84924       };
84925     } catch (...) {
84926       {
84927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84928       };
84929     }
84930   }
84931
84932   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
84933   return jresult;
84934 }
84935
84936
84937 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityManager() {
84938   void * jresult ;
84939   Dali::Toolkit::AccessibilityManager *result = 0 ;
84940
84941   {
84942     try {
84943       result = (Dali::Toolkit::AccessibilityManager *)new Dali::Toolkit::AccessibilityManager();
84944     } catch (std::out_of_range& e) {
84945       {
84946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84947       };
84948     } catch (std::exception& e) {
84949       {
84950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84951       };
84952     } catch (Dali::DaliException e) {
84953       {
84954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84955       };
84956     } catch (...) {
84957       {
84958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84959       };
84960     }
84961   }
84962
84963   jresult = (void *)result;
84964   return jresult;
84965 }
84966
84967
84968 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityManager(void * jarg1) {
84969   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84970
84971   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84972   {
84973     try {
84974       delete arg1;
84975     } catch (std::out_of_range& e) {
84976       {
84977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84978       };
84979     } catch (std::exception& e) {
84980       {
84981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84982       };
84983     } catch (Dali::DaliException e) {
84984       {
84985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84986       };
84987     } catch (...) {
84988       {
84989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84990       };
84991     }
84992   }
84993
84994 }
84995
84996
84997 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_Get() {
84998   void * jresult ;
84999   Dali::Toolkit::AccessibilityManager result;
85000
85001   {
85002     try {
85003       result = Dali::Toolkit::AccessibilityManager::Get();
85004     } catch (std::out_of_range& e) {
85005       {
85006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85007       };
85008     } catch (std::exception& e) {
85009       {
85010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85011       };
85012     } catch (Dali::DaliException e) {
85013       {
85014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85015       };
85016     } catch (...) {
85017       {
85018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85019       };
85020     }
85021   }
85022
85023   jresult = new Dali::Toolkit::AccessibilityManager((const Dali::Toolkit::AccessibilityManager &)result);
85024   return jresult;
85025 }
85026
85027
85028 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3, char * jarg4) {
85029   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85030   Dali::Actor arg2 ;
85031   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
85032   std::string *arg4 = 0 ;
85033   Dali::Actor *argp2 ;
85034
85035   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85036   argp2 = (Dali::Actor *)jarg2;
85037   if (!argp2) {
85038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85039     return ;
85040   }
85041   arg2 = *argp2;
85042   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
85043   if (!jarg4) {
85044     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85045     return ;
85046   }
85047   std::string arg4_str(jarg4);
85048   arg4 = &arg4_str;
85049   {
85050     try {
85051       (arg1)->SetAccessibilityAttribute(arg2,arg3,(std::string const &)*arg4);
85052     } catch (std::out_of_range& e) {
85053       {
85054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85055       };
85056     } catch (std::exception& e) {
85057       {
85058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85059       };
85060     } catch (Dali::DaliException e) {
85061       {
85062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85063       };
85064     } catch (...) {
85065       {
85066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85067       };
85068     }
85069   }
85070
85071
85072   //argout typemap for const std::string&
85073
85074 }
85075
85076
85077 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3) {
85078   char * jresult ;
85079   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85080   Dali::Actor arg2 ;
85081   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
85082   Dali::Actor *argp2 ;
85083   std::string result;
85084
85085   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85086   argp2 = (Dali::Actor *)jarg2;
85087   if (!argp2) {
85088     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85089     return 0;
85090   }
85091   arg2 = *argp2;
85092   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
85093   {
85094     try {
85095       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetAccessibilityAttribute(arg2,arg3);
85096     } catch (std::out_of_range& e) {
85097       {
85098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85099       };
85100     } catch (std::exception& e) {
85101       {
85102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85103       };
85104     } catch (Dali::DaliException e) {
85105       {
85106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85107       };
85108     } catch (...) {
85109       {
85110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85111       };
85112     }
85113   }
85114
85115   jresult = SWIG_csharp_string_callback((&result)->c_str());
85116   return jresult;
85117 }
85118
85119
85120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusOrder(void * jarg1, void * jarg2, unsigned int jarg3) {
85121   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85122   Dali::Actor arg2 ;
85123   unsigned int arg3 ;
85124   Dali::Actor *argp2 ;
85125
85126   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85127   argp2 = (Dali::Actor *)jarg2;
85128   if (!argp2) {
85129     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85130     return ;
85131   }
85132   arg2 = *argp2;
85133   arg3 = (unsigned int)jarg3;
85134   {
85135     try {
85136       (arg1)->SetFocusOrder(arg2,arg3);
85137     } catch (std::out_of_range& e) {
85138       {
85139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85140       };
85141     } catch (std::exception& e) {
85142       {
85143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85144       };
85145     } catch (Dali::DaliException e) {
85146       {
85147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85148       };
85149     } catch (...) {
85150       {
85151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85152       };
85153     }
85154   }
85155
85156 }
85157
85158
85159 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusOrder(void * jarg1, void * jarg2) {
85160   unsigned int jresult ;
85161   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85162   Dali::Actor arg2 ;
85163   Dali::Actor *argp2 ;
85164   unsigned int result;
85165
85166   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85167   argp2 = (Dali::Actor *)jarg2;
85168   if (!argp2) {
85169     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85170     return 0;
85171   }
85172   arg2 = *argp2;
85173   {
85174     try {
85175       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetFocusOrder(arg2);
85176     } catch (std::out_of_range& e) {
85177       {
85178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85179       };
85180     } catch (std::exception& e) {
85181       {
85182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85183       };
85184     } catch (Dali::DaliException e) {
85185       {
85186         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85187       };
85188     } catch (...) {
85189       {
85190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85191       };
85192     }
85193   }
85194
85195   jresult = result;
85196   return jresult;
85197 }
85198
85199
85200 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GenerateNewFocusOrder(void * jarg1) {
85201   unsigned int jresult ;
85202   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85203   unsigned int result;
85204
85205   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85206   {
85207     try {
85208       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GenerateNewFocusOrder();
85209     } catch (std::out_of_range& e) {
85210       {
85211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85212       };
85213     } catch (std::exception& e) {
85214       {
85215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85216       };
85217     } catch (Dali::DaliException e) {
85218       {
85219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85220       };
85221     } catch (...) {
85222       {
85223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85224       };
85225     }
85226   }
85227
85228   jresult = result;
85229   return jresult;
85230 }
85231
85232
85233 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetActorByFocusOrder(void * jarg1, unsigned int jarg2) {
85234   void * jresult ;
85235   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85236   unsigned int arg2 ;
85237   Dali::Actor result;
85238
85239   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85240   arg2 = (unsigned int)jarg2;
85241   {
85242     try {
85243       result = (arg1)->GetActorByFocusOrder(arg2);
85244     } catch (std::out_of_range& e) {
85245       {
85246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85247       };
85248     } catch (std::exception& e) {
85249       {
85250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85251       };
85252     } catch (Dali::DaliException e) {
85253       {
85254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85255       };
85256     } catch (...) {
85257       {
85258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85259       };
85260     }
85261   }
85262
85263   jresult = new Dali::Actor((const Dali::Actor &)result);
85264   return jresult;
85265 }
85266
85267
85268 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetCurrentFocusActor(void * jarg1, void * jarg2) {
85269   unsigned int jresult ;
85270   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85271   Dali::Actor arg2 ;
85272   Dali::Actor *argp2 ;
85273   bool result;
85274
85275   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85276   argp2 = (Dali::Actor *)jarg2;
85277   if (!argp2) {
85278     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85279     return 0;
85280   }
85281   arg2 = *argp2;
85282   {
85283     try {
85284       result = (bool)(arg1)->SetCurrentFocusActor(arg2);
85285     } catch (std::out_of_range& e) {
85286       {
85287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85288       };
85289     } catch (std::exception& e) {
85290       {
85291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85292       };
85293     } catch (Dali::DaliException e) {
85294       {
85295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85296       };
85297     } catch (...) {
85298       {
85299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85300       };
85301     }
85302   }
85303
85304   jresult = result;
85305   return jresult;
85306 }
85307
85308
85309 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusActor(void * jarg1) {
85310   void * jresult ;
85311   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85312   Dali::Actor result;
85313
85314   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85315   {
85316     try {
85317       result = (arg1)->GetCurrentFocusActor();
85318     } catch (std::out_of_range& e) {
85319       {
85320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85321       };
85322     } catch (std::exception& e) {
85323       {
85324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85325       };
85326     } catch (Dali::DaliException e) {
85327       {
85328         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85329       };
85330     } catch (...) {
85331       {
85332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85333       };
85334     }
85335   }
85336
85337   jresult = new Dali::Actor((const Dali::Actor &)result);
85338   return jresult;
85339 }
85340
85341
85342 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusGroup(void * jarg1) {
85343   void * jresult ;
85344   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85345   Dali::Actor result;
85346
85347   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85348   {
85349     try {
85350       result = (arg1)->GetCurrentFocusGroup();
85351     } catch (std::out_of_range& e) {
85352       {
85353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85354       };
85355     } catch (std::exception& e) {
85356       {
85357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85358       };
85359     } catch (Dali::DaliException e) {
85360       {
85361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85362       };
85363     } catch (...) {
85364       {
85365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85366       };
85367     }
85368   }
85369
85370   jresult = new Dali::Actor((const Dali::Actor &)result);
85371   return jresult;
85372 }
85373
85374
85375 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusOrder(void * jarg1) {
85376   unsigned int jresult ;
85377   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85378   unsigned int result;
85379
85380   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85381   {
85382     try {
85383       result = (unsigned int)(arg1)->GetCurrentFocusOrder();
85384     } catch (std::out_of_range& e) {
85385       {
85386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85387       };
85388     } catch (std::exception& e) {
85389       {
85390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85391       };
85392     } catch (Dali::DaliException e) {
85393       {
85394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85395       };
85396     } catch (...) {
85397       {
85398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85399       };
85400     }
85401   }
85402
85403   jresult = result;
85404   return jresult;
85405 }
85406
85407
85408 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusForward(void * jarg1) {
85409   unsigned int jresult ;
85410   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85411   bool result;
85412
85413   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85414   {
85415     try {
85416       result = (bool)(arg1)->MoveFocusForward();
85417     } catch (std::out_of_range& e) {
85418       {
85419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85420       };
85421     } catch (std::exception& e) {
85422       {
85423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85424       };
85425     } catch (Dali::DaliException e) {
85426       {
85427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85428       };
85429     } catch (...) {
85430       {
85431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85432       };
85433     }
85434   }
85435
85436   jresult = result;
85437   return jresult;
85438 }
85439
85440
85441 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusBackward(void * jarg1) {
85442   unsigned int jresult ;
85443   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85444   bool result;
85445
85446   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85447   {
85448     try {
85449       result = (bool)(arg1)->MoveFocusBackward();
85450     } catch (std::out_of_range& e) {
85451       {
85452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85453       };
85454     } catch (std::exception& e) {
85455       {
85456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85457       };
85458     } catch (Dali::DaliException e) {
85459       {
85460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85461       };
85462     } catch (...) {
85463       {
85464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85465       };
85466     }
85467   }
85468
85469   jresult = result;
85470   return jresult;
85471 }
85472
85473
85474 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_ClearFocus(void * jarg1) {
85475   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85476
85477   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85478   {
85479     try {
85480       (arg1)->ClearFocus();
85481     } catch (std::out_of_range& e) {
85482       {
85483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85484       };
85485     } catch (std::exception& e) {
85486       {
85487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85488       };
85489     } catch (Dali::DaliException e) {
85490       {
85491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85492       };
85493     } catch (...) {
85494       {
85495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85496       };
85497     }
85498   }
85499
85500 }
85501
85502
85503 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_Reset(void * jarg1) {
85504   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85505
85506   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85507   {
85508     try {
85509       (arg1)->Reset();
85510     } catch (std::out_of_range& e) {
85511       {
85512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85513       };
85514     } catch (std::exception& e) {
85515       {
85516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85517       };
85518     } catch (Dali::DaliException e) {
85519       {
85520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85521       };
85522     } catch (...) {
85523       {
85524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85525       };
85526     }
85527   }
85528
85529 }
85530
85531
85532 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusGroup(void * jarg1, void * jarg2, unsigned int jarg3) {
85533   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85534   Dali::Actor arg2 ;
85535   bool arg3 ;
85536   Dali::Actor *argp2 ;
85537
85538   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85539   argp2 = (Dali::Actor *)jarg2;
85540   if (!argp2) {
85541     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85542     return ;
85543   }
85544   arg2 = *argp2;
85545   arg3 = jarg3 ? true : false;
85546   {
85547     try {
85548       (arg1)->SetFocusGroup(arg2,arg3);
85549     } catch (std::out_of_range& e) {
85550       {
85551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85552       };
85553     } catch (std::exception& e) {
85554       {
85555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85556       };
85557     } catch (Dali::DaliException e) {
85558       {
85559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85560       };
85561     } catch (...) {
85562       {
85563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85564       };
85565     }
85566   }
85567
85568 }
85569
85570
85571 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_IsFocusGroup(void * jarg1, void * jarg2) {
85572   unsigned int jresult ;
85573   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85574   Dali::Actor arg2 ;
85575   Dali::Actor *argp2 ;
85576   bool result;
85577
85578   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85579   argp2 = (Dali::Actor *)jarg2;
85580   if (!argp2) {
85581     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85582     return 0;
85583   }
85584   arg2 = *argp2;
85585   {
85586     try {
85587       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->IsFocusGroup(arg2);
85588     } catch (std::out_of_range& e) {
85589       {
85590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85591       };
85592     } catch (std::exception& e) {
85593       {
85594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85595       };
85596     } catch (Dali::DaliException e) {
85597       {
85598         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85599       };
85600     } catch (...) {
85601       {
85602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85603       };
85604     }
85605   }
85606
85607   jresult = result;
85608   return jresult;
85609 }
85610
85611
85612 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetGroupMode(void * jarg1, unsigned int jarg2) {
85613   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85614   bool arg2 ;
85615
85616   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85617   arg2 = jarg2 ? true : false;
85618   {
85619     try {
85620       (arg1)->SetGroupMode(arg2);
85621     } catch (std::out_of_range& e) {
85622       {
85623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85624       };
85625     } catch (std::exception& e) {
85626       {
85627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85628       };
85629     } catch (Dali::DaliException e) {
85630       {
85631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85632       };
85633     } catch (...) {
85634       {
85635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85636       };
85637     }
85638   }
85639
85640 }
85641
85642
85643 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetGroupMode(void * jarg1) {
85644   unsigned int jresult ;
85645   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85646   bool result;
85647
85648   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85649   {
85650     try {
85651       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetGroupMode();
85652     } catch (std::out_of_range& e) {
85653       {
85654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85655       };
85656     } catch (std::exception& e) {
85657       {
85658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85659       };
85660     } catch (Dali::DaliException e) {
85661       {
85662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85663       };
85664     } catch (...) {
85665       {
85666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85667       };
85668     }
85669   }
85670
85671   jresult = result;
85672   return jresult;
85673 }
85674
85675
85676 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetWrapMode(void * jarg1, unsigned int jarg2) {
85677   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85678   bool arg2 ;
85679
85680   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85681   arg2 = jarg2 ? true : false;
85682   {
85683     try {
85684       (arg1)->SetWrapMode(arg2);
85685     } catch (std::out_of_range& e) {
85686       {
85687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85688       };
85689     } catch (std::exception& e) {
85690       {
85691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85692       };
85693     } catch (Dali::DaliException e) {
85694       {
85695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85696       };
85697     } catch (...) {
85698       {
85699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85700       };
85701     }
85702   }
85703
85704 }
85705
85706
85707 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetWrapMode(void * jarg1) {
85708   unsigned int jresult ;
85709   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85710   bool result;
85711
85712   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85713   {
85714     try {
85715       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetWrapMode();
85716     } catch (std::out_of_range& e) {
85717       {
85718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85719       };
85720     } catch (std::exception& e) {
85721       {
85722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85723       };
85724     } catch (Dali::DaliException e) {
85725       {
85726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85727       };
85728     } catch (...) {
85729       {
85730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85731       };
85732     }
85733   }
85734
85735   jresult = result;
85736   return jresult;
85737 }
85738
85739
85740 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusIndicatorActor(void * jarg1, void * jarg2) {
85741   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85742   Dali::Actor arg2 ;
85743   Dali::Actor *argp2 ;
85744
85745   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85746   argp2 = (Dali::Actor *)jarg2;
85747   if (!argp2) {
85748     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85749     return ;
85750   }
85751   arg2 = *argp2;
85752   {
85753     try {
85754       (arg1)->SetFocusIndicatorActor(arg2);
85755     } catch (std::out_of_range& e) {
85756       {
85757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85758       };
85759     } catch (std::exception& e) {
85760       {
85761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85762       };
85763     } catch (Dali::DaliException e) {
85764       {
85765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85766       };
85767     } catch (...) {
85768       {
85769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85770       };
85771     }
85772   }
85773
85774 }
85775
85776
85777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusIndicatorActor(void * jarg1) {
85778   void * jresult ;
85779   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85780   Dali::Actor result;
85781
85782   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85783   {
85784     try {
85785       result = (arg1)->GetFocusIndicatorActor();
85786     } catch (std::out_of_range& e) {
85787       {
85788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85789       };
85790     } catch (std::exception& e) {
85791       {
85792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85793       };
85794     } catch (Dali::DaliException e) {
85795       {
85796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85797       };
85798     } catch (...) {
85799       {
85800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85801       };
85802     }
85803   }
85804
85805   jresult = new Dali::Actor((const Dali::Actor &)result);
85806   return jresult;
85807 }
85808
85809
85810 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusGroup(void * jarg1, void * jarg2) {
85811   void * jresult ;
85812   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85813   Dali::Actor arg2 ;
85814   Dali::Actor *argp2 ;
85815   Dali::Actor result;
85816
85817   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85818   argp2 = (Dali::Actor *)jarg2;
85819   if (!argp2) {
85820     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85821     return 0;
85822   }
85823   arg2 = *argp2;
85824   {
85825     try {
85826       result = (arg1)->GetFocusGroup(arg2);
85827     } catch (std::out_of_range& e) {
85828       {
85829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85830       };
85831     } catch (std::exception& e) {
85832       {
85833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85834       };
85835     } catch (Dali::DaliException e) {
85836       {
85837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85838       };
85839     } catch (...) {
85840       {
85841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85842       };
85843     }
85844   }
85845
85846   jresult = new Dali::Actor((const Dali::Actor &)result);
85847   return jresult;
85848 }
85849
85850
85851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetReadPosition(void * jarg1) {
85852   void * jresult ;
85853   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85854   Dali::Vector2 result;
85855
85856   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85857   {
85858     try {
85859       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetReadPosition();
85860     } catch (std::out_of_range& e) {
85861       {
85862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85863       };
85864     } catch (std::exception& e) {
85865       {
85866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85867       };
85868     } catch (Dali::DaliException e) {
85869       {
85870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85871       };
85872     } catch (...) {
85873       {
85874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85875       };
85876     }
85877   }
85878
85879   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
85880   return jresult;
85881 }
85882
85883
85884 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusChangedSignal(void * jarg1) {
85885   void * jresult ;
85886   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85887   Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *result = 0 ;
85888
85889   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85890   {
85891     try {
85892       result = (Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *) &(arg1)->FocusChangedSignal();
85893     } catch (std::out_of_range& e) {
85894       {
85895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85896       };
85897     } catch (std::exception& e) {
85898       {
85899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85900       };
85901     } catch (Dali::DaliException e) {
85902       {
85903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85904       };
85905     } catch (...) {
85906       {
85907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85908       };
85909     }
85910   }
85911
85912   jresult = (void *)result;
85913   return jresult;
85914 }
85915
85916
85917 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusOvershotSignal(void * jarg1) {
85918   void * jresult ;
85919   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85920   Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *result = 0 ;
85921
85922   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85923   {
85924     try {
85925       result = (Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *) &(arg1)->FocusOvershotSignal();
85926     } catch (std::out_of_range& e) {
85927       {
85928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85929       };
85930     } catch (std::exception& e) {
85931       {
85932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85933       };
85934     } catch (Dali::DaliException e) {
85935       {
85936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85937       };
85938     } catch (...) {
85939       {
85940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85941       };
85942     }
85943   }
85944
85945   jresult = (void *)result;
85946   return jresult;
85947 }
85948
85949
85950 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusedActorActivatedSignal(void * jarg1) {
85951   void * jresult ;
85952   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85953   Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *result = 0 ;
85954
85955   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85956   {
85957     try {
85958       result = (Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *) &(arg1)->FocusedActorActivatedSignal();
85959     } catch (std::out_of_range& e) {
85960       {
85961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85962       };
85963     } catch (std::exception& e) {
85964       {
85965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85966       };
85967     } catch (Dali::DaliException e) {
85968       {
85969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85970       };
85971     } catch (...) {
85972       {
85973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85974       };
85975     }
85976   }
85977
85978   jresult = (void *)result;
85979   return jresult;
85980 }
85981
85982
85983 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_StatusChangedSignal(void * jarg1) {
85984   void * jresult ;
85985   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85986   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85987
85988   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85989   {
85990     try {
85991       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->StatusChangedSignal();
85992     } catch (std::out_of_range& e) {
85993       {
85994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85995       };
85996     } catch (std::exception& e) {
85997       {
85998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85999       };
86000     } catch (Dali::DaliException e) {
86001       {
86002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86003       };
86004     } catch (...) {
86005       {
86006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86007       };
86008     }
86009   }
86010
86011   jresult = (void *)result;
86012   return jresult;
86013 }
86014
86015
86016 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionNextSignal(void * jarg1) {
86017   void * jresult ;
86018   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86019   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86020
86021   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86022   {
86023     try {
86024       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionNextSignal();
86025     } catch (std::out_of_range& e) {
86026       {
86027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86028       };
86029     } catch (std::exception& e) {
86030       {
86031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86032       };
86033     } catch (Dali::DaliException e) {
86034       {
86035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86036       };
86037     } catch (...) {
86038       {
86039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86040       };
86041     }
86042   }
86043
86044   jresult = (void *)result;
86045   return jresult;
86046 }
86047
86048
86049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPreviousSignal(void * jarg1) {
86050   void * jresult ;
86051   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86052   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86053
86054   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86055   {
86056     try {
86057       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPreviousSignal();
86058     } catch (std::out_of_range& e) {
86059       {
86060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86061       };
86062     } catch (std::exception& e) {
86063       {
86064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86065       };
86066     } catch (Dali::DaliException e) {
86067       {
86068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86069       };
86070     } catch (...) {
86071       {
86072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86073       };
86074     }
86075   }
86076
86077   jresult = (void *)result;
86078   return jresult;
86079 }
86080
86081
86082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionActivateSignal(void * jarg1) {
86083   void * jresult ;
86084   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86085   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86086
86087   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86088   {
86089     try {
86090       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionActivateSignal();
86091     } catch (std::out_of_range& e) {
86092       {
86093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86094       };
86095     } catch (std::exception& e) {
86096       {
86097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86098       };
86099     } catch (Dali::DaliException e) {
86100       {
86101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86102       };
86103     } catch (...) {
86104       {
86105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86106       };
86107     }
86108   }
86109
86110   jresult = (void *)result;
86111   return jresult;
86112 }
86113
86114
86115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadSignal(void * jarg1) {
86116   void * jresult ;
86117   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86118   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86119
86120   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86121   {
86122     try {
86123       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadSignal();
86124     } catch (std::out_of_range& e) {
86125       {
86126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86127       };
86128     } catch (std::exception& e) {
86129       {
86130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86131       };
86132     } catch (Dali::DaliException e) {
86133       {
86134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86135       };
86136     } catch (...) {
86137       {
86138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86139       };
86140     }
86141   }
86142
86143   jresult = (void *)result;
86144   return jresult;
86145 }
86146
86147
86148 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionOverSignal(void * jarg1) {
86149   void * jresult ;
86150   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86151   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86152
86153   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86154   {
86155     try {
86156       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionOverSignal();
86157     } catch (std::out_of_range& e) {
86158       {
86159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86160       };
86161     } catch (std::exception& e) {
86162       {
86163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86164       };
86165     } catch (Dali::DaliException e) {
86166       {
86167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86168       };
86169     } catch (...) {
86170       {
86171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86172       };
86173     }
86174   }
86175
86176   jresult = (void *)result;
86177   return jresult;
86178 }
86179
86180
86181 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadNextSignal(void * jarg1) {
86182   void * jresult ;
86183   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86184   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86185
86186   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86187   {
86188     try {
86189       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadNextSignal();
86190     } catch (std::out_of_range& e) {
86191       {
86192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86193       };
86194     } catch (std::exception& e) {
86195       {
86196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86197       };
86198     } catch (Dali::DaliException e) {
86199       {
86200         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86201       };
86202     } catch (...) {
86203       {
86204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86205       };
86206     }
86207   }
86208
86209   jresult = (void *)result;
86210   return jresult;
86211 }
86212
86213
86214 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPreviousSignal(void * jarg1) {
86215   void * jresult ;
86216   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86217   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86218
86219   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86220   {
86221     try {
86222       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPreviousSignal();
86223     } catch (std::out_of_range& e) {
86224       {
86225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86226       };
86227     } catch (std::exception& e) {
86228       {
86229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86230       };
86231     } catch (Dali::DaliException e) {
86232       {
86233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86234       };
86235     } catch (...) {
86236       {
86237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86238       };
86239     }
86240   }
86241
86242   jresult = (void *)result;
86243   return jresult;
86244 }
86245
86246
86247 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionUpSignal(void * jarg1) {
86248   void * jresult ;
86249   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86250   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86251
86252   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86253   {
86254     try {
86255       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionUpSignal();
86256     } catch (std::out_of_range& e) {
86257       {
86258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86259       };
86260     } catch (std::exception& e) {
86261       {
86262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86263       };
86264     } catch (Dali::DaliException e) {
86265       {
86266         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86267       };
86268     } catch (...) {
86269       {
86270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86271       };
86272     }
86273   }
86274
86275   jresult = (void *)result;
86276   return jresult;
86277 }
86278
86279
86280 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionDownSignal(void * jarg1) {
86281   void * jresult ;
86282   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86283   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86284
86285   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86286   {
86287     try {
86288       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionDownSignal();
86289     } catch (std::out_of_range& e) {
86290       {
86291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86292       };
86293     } catch (std::exception& e) {
86294       {
86295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86296       };
86297     } catch (Dali::DaliException e) {
86298       {
86299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86300       };
86301     } catch (...) {
86302       {
86303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86304       };
86305     }
86306   }
86307
86308   jresult = (void *)result;
86309   return jresult;
86310 }
86311
86312
86313 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionClearFocusSignal(void * jarg1) {
86314   void * jresult ;
86315   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86316   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86317
86318   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86319   {
86320     try {
86321       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionClearFocusSignal();
86322     } catch (std::out_of_range& e) {
86323       {
86324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86325       };
86326     } catch (std::exception& e) {
86327       {
86328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86329       };
86330     } catch (Dali::DaliException e) {
86331       {
86332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86333       };
86334     } catch (...) {
86335       {
86336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86337       };
86338     }
86339   }
86340
86341   jresult = (void *)result;
86342   return jresult;
86343 }
86344
86345
86346 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionBackSignal(void * jarg1) {
86347   void * jresult ;
86348   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86349   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86350
86351   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86352   {
86353     try {
86354       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionBackSignal();
86355     } catch (std::out_of_range& e) {
86356       {
86357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86358       };
86359     } catch (std::exception& e) {
86360       {
86361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86362       };
86363     } catch (Dali::DaliException e) {
86364       {
86365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86366       };
86367     } catch (...) {
86368       {
86369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86370       };
86371     }
86372   }
86373
86374   jresult = (void *)result;
86375   return jresult;
86376 }
86377
86378
86379 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollUpSignal(void * jarg1) {
86380   void * jresult ;
86381   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86382   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86383
86384   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86385   {
86386     try {
86387       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollUpSignal();
86388     } catch (std::out_of_range& e) {
86389       {
86390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86391       };
86392     } catch (std::exception& e) {
86393       {
86394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86395       };
86396     } catch (Dali::DaliException e) {
86397       {
86398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86399       };
86400     } catch (...) {
86401       {
86402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86403       };
86404     }
86405   }
86406
86407   jresult = (void *)result;
86408   return jresult;
86409 }
86410
86411
86412 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollDownSignal(void * jarg1) {
86413   void * jresult ;
86414   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86415   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86416
86417   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86418   {
86419     try {
86420       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollDownSignal();
86421     } catch (std::out_of_range& e) {
86422       {
86423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86424       };
86425     } catch (std::exception& e) {
86426       {
86427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86428       };
86429     } catch (Dali::DaliException e) {
86430       {
86431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86432       };
86433     } catch (...) {
86434       {
86435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86436       };
86437     }
86438   }
86439
86440   jresult = (void *)result;
86441   return jresult;
86442 }
86443
86444
86445 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageLeftSignal(void * jarg1) {
86446   void * jresult ;
86447   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86448   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86449
86450   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86451   {
86452     try {
86453       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageLeftSignal();
86454     } catch (std::out_of_range& e) {
86455       {
86456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86457       };
86458     } catch (std::exception& e) {
86459       {
86460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86461       };
86462     } catch (Dali::DaliException e) {
86463       {
86464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86465       };
86466     } catch (...) {
86467       {
86468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86469       };
86470     }
86471   }
86472
86473   jresult = (void *)result;
86474   return jresult;
86475 }
86476
86477
86478 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageRightSignal(void * jarg1) {
86479   void * jresult ;
86480   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86481   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86482
86483   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86484   {
86485     try {
86486       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageRightSignal();
86487     } catch (std::out_of_range& e) {
86488       {
86489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86490       };
86491     } catch (std::exception& e) {
86492       {
86493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86494       };
86495     } catch (Dali::DaliException e) {
86496       {
86497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86498       };
86499     } catch (...) {
86500       {
86501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86502       };
86503     }
86504   }
86505
86506   jresult = (void *)result;
86507   return jresult;
86508 }
86509
86510
86511 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageUpSignal(void * jarg1) {
86512   void * jresult ;
86513   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86514   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86515
86516   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86517   {
86518     try {
86519       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageUpSignal();
86520     } catch (std::out_of_range& e) {
86521       {
86522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86523       };
86524     } catch (std::exception& e) {
86525       {
86526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86527       };
86528     } catch (Dali::DaliException e) {
86529       {
86530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86531       };
86532     } catch (...) {
86533       {
86534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86535       };
86536     }
86537   }
86538
86539   jresult = (void *)result;
86540   return jresult;
86541 }
86542
86543
86544 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageDownSignal(void * jarg1) {
86545   void * jresult ;
86546   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86547   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86548
86549   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86550   {
86551     try {
86552       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageDownSignal();
86553     } catch (std::out_of_range& e) {
86554       {
86555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86556       };
86557     } catch (std::exception& e) {
86558       {
86559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86560       };
86561     } catch (Dali::DaliException e) {
86562       {
86563         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86564       };
86565     } catch (...) {
86566       {
86567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86568       };
86569     }
86570   }
86571
86572   jresult = (void *)result;
86573   return jresult;
86574 }
86575
86576
86577 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToFirstSignal(void * jarg1) {
86578   void * jresult ;
86579   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86580   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86581
86582   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86583   {
86584     try {
86585       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToFirstSignal();
86586     } catch (std::out_of_range& e) {
86587       {
86588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86589       };
86590     } catch (std::exception& e) {
86591       {
86592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86593       };
86594     } catch (Dali::DaliException e) {
86595       {
86596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86597       };
86598     } catch (...) {
86599       {
86600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86601       };
86602     }
86603   }
86604
86605   jresult = (void *)result;
86606   return jresult;
86607 }
86608
86609
86610 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToLastSignal(void * jarg1) {
86611   void * jresult ;
86612   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86613   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86614
86615   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86616   {
86617     try {
86618       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToLastSignal();
86619     } catch (std::out_of_range& e) {
86620       {
86621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86622       };
86623     } catch (std::exception& e) {
86624       {
86625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86626       };
86627     } catch (Dali::DaliException e) {
86628       {
86629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86630       };
86631     } catch (...) {
86632       {
86633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86634       };
86635     }
86636   }
86637
86638   jresult = (void *)result;
86639   return jresult;
86640 }
86641
86642
86643 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromTopSignal(void * jarg1) {
86644   void * jresult ;
86645   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86646   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86647
86648   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86649   {
86650     try {
86651       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromTopSignal();
86652     } catch (std::out_of_range& e) {
86653       {
86654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86655       };
86656     } catch (std::exception& e) {
86657       {
86658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86659       };
86660     } catch (Dali::DaliException e) {
86661       {
86662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86663       };
86664     } catch (...) {
86665       {
86666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86667       };
86668     }
86669   }
86670
86671   jresult = (void *)result;
86672   return jresult;
86673 }
86674
86675
86676 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromNextSignal(void * jarg1) {
86677   void * jresult ;
86678   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86679   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86680
86681   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86682   {
86683     try {
86684       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromNextSignal();
86685     } catch (std::out_of_range& e) {
86686       {
86687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86688       };
86689     } catch (std::exception& e) {
86690       {
86691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86692       };
86693     } catch (Dali::DaliException e) {
86694       {
86695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86696       };
86697     } catch (...) {
86698       {
86699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86700       };
86701     }
86702   }
86703
86704   jresult = (void *)result;
86705   return jresult;
86706 }
86707
86708
86709 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionZoomSignal(void * jarg1) {
86710   void * jresult ;
86711   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86712   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86713
86714   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86715   {
86716     try {
86717       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionZoomSignal();
86718     } catch (std::out_of_range& e) {
86719       {
86720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86721       };
86722     } catch (std::exception& e) {
86723       {
86724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86725       };
86726     } catch (Dali::DaliException e) {
86727       {
86728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86729       };
86730     } catch (...) {
86731       {
86732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86733       };
86734     }
86735   }
86736
86737   jresult = (void *)result;
86738   return jresult;
86739 }
86740
86741
86742 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadIndicatorInformationSignal(void * jarg1) {
86743   void * jresult ;
86744   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86745   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86746
86747   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86748   {
86749     try {
86750       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadIndicatorInformationSignal();
86751     } catch (std::out_of_range& e) {
86752       {
86753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86754       };
86755     } catch (std::exception& e) {
86756       {
86757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86758       };
86759     } catch (Dali::DaliException e) {
86760       {
86761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86762       };
86763     } catch (...) {
86764       {
86765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86766       };
86767     }
86768   }
86769
86770   jresult = (void *)result;
86771   return jresult;
86772 }
86773
86774
86775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPauseResumeSignal(void * jarg1) {
86776   void * jresult ;
86777   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86778   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86779
86780   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86781   {
86782     try {
86783       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPauseResumeSignal();
86784     } catch (std::out_of_range& e) {
86785       {
86786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86787       };
86788     } catch (std::exception& e) {
86789       {
86790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86791       };
86792     } catch (Dali::DaliException e) {
86793       {
86794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86795       };
86796     } catch (...) {
86797       {
86798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86799       };
86800     }
86801   }
86802
86803   jresult = (void *)result;
86804   return jresult;
86805 }
86806
86807
86808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionStartStopSignal(void * jarg1) {
86809   void * jresult ;
86810   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86811   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86812
86813   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86814   {
86815     try {
86816       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionStartStopSignal();
86817     } catch (std::out_of_range& e) {
86818       {
86819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86820       };
86821     } catch (std::exception& e) {
86822       {
86823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86824       };
86825     } catch (Dali::DaliException e) {
86826       {
86827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86828       };
86829     } catch (...) {
86830       {
86831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86832       };
86833     }
86834   }
86835
86836   jresult = (void *)result;
86837   return jresult;
86838 }
86839
86840
86841 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollSignal(void * jarg1) {
86842   void * jresult ;
86843   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86844   Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *result = 0 ;
86845
86846   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86847   {
86848     try {
86849       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *) &(arg1)->ActionScrollSignal();
86850     } catch (std::out_of_range& e) {
86851       {
86852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86853       };
86854     } catch (std::exception& e) {
86855       {
86856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86857       };
86858     } catch (Dali::DaliException e) {
86859       {
86860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86861       };
86862     } catch (...) {
86863       {
86864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86865       };
86866     }
86867   }
86868
86869   jresult = (void *)result;
86870   return jresult;
86871 }
86872
86873
86874 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleManager() {
86875   void * jresult ;
86876   Dali::Toolkit::StyleManager *result = 0 ;
86877
86878   {
86879     try {
86880       result = (Dali::Toolkit::StyleManager *)new Dali::Toolkit::StyleManager();
86881     } catch (std::out_of_range& e) {
86882       {
86883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86884       };
86885     } catch (std::exception& e) {
86886       {
86887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86888       };
86889     } catch (Dali::DaliException e) {
86890       {
86891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86892       };
86893     } catch (...) {
86894       {
86895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86896       };
86897     }
86898   }
86899
86900   jresult = (void *)result;
86901   return jresult;
86902 }
86903
86904
86905 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleManager(void * jarg1) {
86906   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86907
86908   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86909   {
86910     try {
86911       delete arg1;
86912     } catch (std::out_of_range& e) {
86913       {
86914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86915       };
86916     } catch (std::exception& e) {
86917       {
86918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86919       };
86920     } catch (Dali::DaliException e) {
86921       {
86922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86923       };
86924     } catch (...) {
86925       {
86926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86927       };
86928     }
86929   }
86930
86931 }
86932
86933
86934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_Get() {
86935   void * jresult ;
86936   Dali::Toolkit::StyleManager result;
86937
86938   {
86939     try {
86940       result = Dali::Toolkit::StyleManager::Get();
86941     } catch (std::out_of_range& e) {
86942       {
86943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86944       };
86945     } catch (std::exception& e) {
86946       {
86947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86948       };
86949     } catch (Dali::DaliException e) {
86950       {
86951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86952       };
86953     } catch (...) {
86954       {
86955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86956       };
86957     }
86958   }
86959
86960   jresult = new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)result);
86961   return jresult;
86962 }
86963
86964
86965 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyTheme(void * jarg1, char * jarg2) {
86966   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86967   std::string *arg2 = 0 ;
86968
86969   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86970   if (!jarg2) {
86971     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86972     return ;
86973   }
86974   std::string arg2_str(jarg2);
86975   arg2 = &arg2_str;
86976   {
86977     try {
86978       (arg1)->ApplyTheme((std::string const &)*arg2);
86979     } catch (std::out_of_range& e) {
86980       {
86981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86982       };
86983     } catch (std::exception& e) {
86984       {
86985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86986       };
86987     } catch (Dali::DaliException e) {
86988       {
86989         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86990       };
86991     } catch (...) {
86992       {
86993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86994       };
86995     }
86996   }
86997
86998
86999   //argout typemap for const std::string&
87000
87001 }
87002
87003
87004 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyDefaultTheme(void * jarg1) {
87005   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
87006
87007   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
87008   {
87009     try {
87010       (arg1)->ApplyDefaultTheme();
87011     } catch (std::out_of_range& e) {
87012       {
87013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87014       };
87015     } catch (std::exception& e) {
87016       {
87017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87018       };
87019     } catch (Dali::DaliException e) {
87020       {
87021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87022       };
87023     } catch (...) {
87024       {
87025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87026       };
87027     }
87028   }
87029
87030 }
87031
87032
87033 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_SetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
87034   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
87035   std::string *arg2 = 0 ;
87036   Dali::Property::Value *arg3 = 0 ;
87037
87038   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
87039   if (!jarg2) {
87040     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
87041     return ;
87042   }
87043   std::string arg2_str(jarg2);
87044   arg2 = &arg2_str;
87045   arg3 = (Dali::Property::Value *)jarg3;
87046   if (!arg3) {
87047     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
87048     return ;
87049   }
87050   {
87051     try {
87052       (arg1)->SetStyleConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
87053     } catch (std::out_of_range& e) {
87054       {
87055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87056       };
87057     } catch (std::exception& e) {
87058       {
87059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87060       };
87061     } catch (Dali::DaliException e) {
87062       {
87063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87064       };
87065     } catch (...) {
87066       {
87067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87068       };
87069     }
87070   }
87071
87072
87073   //argout typemap for const std::string&
87074
87075 }
87076
87077
87078 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleManager_GetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
87079   unsigned int jresult ;
87080   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
87081   std::string *arg2 = 0 ;
87082   Dali::Property::Value *arg3 = 0 ;
87083   bool result;
87084
87085   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
87086   if (!jarg2) {
87087     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
87088     return 0;
87089   }
87090   std::string arg2_str(jarg2);
87091   arg2 = &arg2_str;
87092   arg3 = (Dali::Property::Value *)jarg3;
87093   if (!arg3) {
87094     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value & type is null", 0);
87095     return 0;
87096   }
87097   {
87098     try {
87099       result = (bool)(arg1)->GetStyleConstant((std::string const &)*arg2,*arg3);
87100     } catch (std::out_of_range& e) {
87101       {
87102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87103       };
87104     } catch (std::exception& e) {
87105       {
87106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87107       };
87108     } catch (Dali::DaliException e) {
87109       {
87110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87111       };
87112     } catch (...) {
87113       {
87114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87115       };
87116     }
87117   }
87118
87119   jresult = result;
87120
87121   //argout typemap for const std::string&
87122
87123   return jresult;
87124 }
87125
87126
87127 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyStyle(void * jarg1, void * jarg2, char * jarg3, char * jarg4) {
87128   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
87129   Dali::Toolkit::Control arg2 ;
87130   std::string *arg3 = 0 ;
87131   std::string *arg4 = 0 ;
87132   Dali::Toolkit::Control *argp2 ;
87133
87134   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
87135   argp2 = (Dali::Toolkit::Control *)jarg2;
87136   if (!argp2) {
87137     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
87138     return ;
87139   }
87140   arg2 = *argp2;
87141   if (!jarg3) {
87142     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
87143     return ;
87144   }
87145   std::string arg3_str(jarg3);
87146   arg3 = &arg3_str;
87147   if (!jarg4) {
87148     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
87149     return ;
87150   }
87151   std::string arg4_str(jarg4);
87152   arg4 = &arg4_str;
87153   {
87154     try {
87155       (arg1)->ApplyStyle(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
87156     } catch (std::out_of_range& e) {
87157       {
87158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87159       };
87160     } catch (std::exception& e) {
87161       {
87162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87163       };
87164     } catch (Dali::DaliException e) {
87165       {
87166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87167       };
87168     } catch (...) {
87169       {
87170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87171       };
87172     }
87173   }
87174
87175
87176   //argout typemap for const std::string&
87177
87178
87179   //argout typemap for const std::string&
87180
87181 }
87182
87183
87184 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_StyleChangedSignal(void * jarg1) {
87185   void * jresult ;
87186   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
87187   Dali::Toolkit::StyleManager::StyleChangedSignalType *result = 0 ;
87188
87189   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
87190   {
87191     try {
87192       result = (Dali::Toolkit::StyleManager::StyleChangedSignalType *) &(arg1)->StyleChangedSignal();
87193     } catch (std::out_of_range& e) {
87194       {
87195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87196       };
87197     } catch (std::exception& e) {
87198       {
87199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87200       };
87201     } catch (Dali::DaliException e) {
87202       {
87203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87204       };
87205     } catch (...) {
87206       {
87207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87208       };
87209     }
87210   }
87211
87212   jresult = (void *)result;
87213   return jresult;
87214 }
87215
87216
87217 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_LOWER_BOUND_get() {
87218   int jresult ;
87219   int result;
87220
87221   result = (int)Dali::Toolkit::Slider::Property::LOWER_BOUND;
87222   jresult = (int)result;
87223   return jresult;
87224 }
87225
87226
87227 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_UPPER_BOUND_get() {
87228   int jresult ;
87229   int result;
87230
87231   result = (int)Dali::Toolkit::Slider::Property::UPPER_BOUND;
87232   jresult = (int)result;
87233   return jresult;
87234 }
87235
87236
87237 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_get() {
87238   int jresult ;
87239   int result;
87240
87241   result = (int)Dali::Toolkit::Slider::Property::VALUE;
87242   jresult = (int)result;
87243   return jresult;
87244 }
87245
87246
87247 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_TRACK_VISUAL_get() {
87248   int jresult ;
87249   int result;
87250
87251   result = (int)Dali::Toolkit::Slider::Property::TRACK_VISUAL;
87252   jresult = (int)result;
87253   return jresult;
87254 }
87255
87256
87257 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_HANDLE_VISUAL_get() {
87258   int jresult ;
87259   int result;
87260
87261   result = (int)Dali::Toolkit::Slider::Property::HANDLE_VISUAL;
87262   jresult = (int)result;
87263   return jresult;
87264 }
87265
87266
87267 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_PROGRESS_VISUAL_get() {
87268   int jresult ;
87269   int result;
87270
87271   result = (int)Dali::Toolkit::Slider::Property::PROGRESS_VISUAL;
87272   jresult = (int)result;
87273   return jresult;
87274 }
87275
87276
87277 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_VISUAL_get() {
87278   int jresult ;
87279   int result;
87280
87281   result = (int)Dali::Toolkit::Slider::Property::POPUP_VISUAL;
87282   jresult = (int)result;
87283   return jresult;
87284 }
87285
87286
87287 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_ARROW_VISUAL_get() {
87288   int jresult ;
87289   int result;
87290
87291   result = (int)Dali::Toolkit::Slider::Property::POPUP_ARROW_VISUAL;
87292   jresult = (int)result;
87293   return jresult;
87294 }
87295
87296
87297 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_DISABLED_COLOR_get() {
87298   int jresult ;
87299   int result;
87300
87301   result = (int)Dali::Toolkit::Slider::Property::DISABLED_COLOR;
87302   jresult = (int)result;
87303   return jresult;
87304 }
87305
87306
87307 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_PRECISION_get() {
87308   int jresult ;
87309   int result;
87310
87311   result = (int)Dali::Toolkit::Slider::Property::VALUE_PRECISION;
87312   jresult = (int)result;
87313   return jresult;
87314 }
87315
87316
87317 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_POPUP_get() {
87318   int jresult ;
87319   int result;
87320
87321   result = (int)Dali::Toolkit::Slider::Property::SHOW_POPUP;
87322   jresult = (int)result;
87323   return jresult;
87324 }
87325
87326
87327 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_VALUE_get() {
87328   int jresult ;
87329   int result;
87330
87331   result = (int)Dali::Toolkit::Slider::Property::SHOW_VALUE;
87332   jresult = (int)result;
87333   return jresult;
87334 }
87335
87336
87337 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARKS_get() {
87338   int jresult ;
87339   int result;
87340
87341   result = (int)Dali::Toolkit::Slider::Property::MARKS;
87342   jresult = (int)result;
87343   return jresult;
87344 }
87345
87346
87347 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SNAP_TO_MARKS_get() {
87348   int jresult ;
87349   int result;
87350
87351   result = (int)Dali::Toolkit::Slider::Property::SNAP_TO_MARKS;
87352   jresult = (int)result;
87353   return jresult;
87354 }
87355
87356
87357 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARK_TOLERANCE_get() {
87358   int jresult ;
87359   int result;
87360
87361   result = (int)Dali::Toolkit::Slider::Property::MARK_TOLERANCE;
87362   jresult = (int)result;
87363   return jresult;
87364 }
87365
87366
87367 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider_Property() {
87368   void * jresult ;
87369   Dali::Toolkit::Slider::Property *result = 0 ;
87370
87371   {
87372     try {
87373       result = (Dali::Toolkit::Slider::Property *)new Dali::Toolkit::Slider::Property();
87374     } catch (std::out_of_range& e) {
87375       {
87376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87377       };
87378     } catch (std::exception& e) {
87379       {
87380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87381       };
87382     } catch (Dali::DaliException e) {
87383       {
87384         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87385       };
87386     } catch (...) {
87387       {
87388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87389       };
87390     }
87391   }
87392
87393   jresult = (void *)result;
87394   return jresult;
87395 }
87396
87397
87398 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider_Property(void * jarg1) {
87399   Dali::Toolkit::Slider::Property *arg1 = (Dali::Toolkit::Slider::Property *) 0 ;
87400
87401   arg1 = (Dali::Toolkit::Slider::Property *)jarg1;
87402   {
87403     try {
87404       delete arg1;
87405     } catch (std::out_of_range& e) {
87406       {
87407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87408       };
87409     } catch (std::exception& e) {
87410       {
87411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87412       };
87413     } catch (Dali::DaliException e) {
87414       {
87415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87416       };
87417     } catch (...) {
87418       {
87419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87420       };
87421     }
87422   }
87423
87424 }
87425
87426
87427 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_New() {
87428   void * jresult ;
87429   Dali::Toolkit::Slider result;
87430
87431   {
87432     try {
87433       result = Dali::Toolkit::Slider::New();
87434     } catch (std::out_of_range& e) {
87435       {
87436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87437       };
87438     } catch (std::exception& e) {
87439       {
87440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87441       };
87442     } catch (Dali::DaliException e) {
87443       {
87444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87445       };
87446     } catch (...) {
87447       {
87448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87449       };
87450     }
87451   }
87452
87453   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
87454   return jresult;
87455 }
87456
87457
87458 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_0() {
87459   void * jresult ;
87460   Dali::Toolkit::Slider *result = 0 ;
87461
87462   {
87463     try {
87464       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider();
87465     } catch (std::out_of_range& e) {
87466       {
87467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87468       };
87469     } catch (std::exception& e) {
87470       {
87471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87472       };
87473     } catch (Dali::DaliException e) {
87474       {
87475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87476       };
87477     } catch (...) {
87478       {
87479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87480       };
87481     }
87482   }
87483
87484   jresult = (void *)result;
87485   return jresult;
87486 }
87487
87488
87489 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_1(void * jarg1) {
87490   void * jresult ;
87491   Dali::Toolkit::Slider *arg1 = 0 ;
87492   Dali::Toolkit::Slider *result = 0 ;
87493
87494   arg1 = (Dali::Toolkit::Slider *)jarg1;
87495   if (!arg1) {
87496     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
87497     return 0;
87498   }
87499   {
87500     try {
87501       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider((Dali::Toolkit::Slider const &)*arg1);
87502     } catch (std::out_of_range& e) {
87503       {
87504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87505       };
87506     } catch (std::exception& e) {
87507       {
87508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87509       };
87510     } catch (Dali::DaliException e) {
87511       {
87512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87513       };
87514     } catch (...) {
87515       {
87516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87517       };
87518     }
87519   }
87520
87521   jresult = (void *)result;
87522   return jresult;
87523 }
87524
87525
87526 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_Assign(void * jarg1, void * jarg2) {
87527   void * jresult ;
87528   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
87529   Dali::Toolkit::Slider *arg2 = 0 ;
87530   Dali::Toolkit::Slider *result = 0 ;
87531
87532   arg1 = (Dali::Toolkit::Slider *)jarg1;
87533   arg2 = (Dali::Toolkit::Slider *)jarg2;
87534   if (!arg2) {
87535     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
87536     return 0;
87537   }
87538   {
87539     try {
87540       result = (Dali::Toolkit::Slider *) &(arg1)->operator =((Dali::Toolkit::Slider const &)*arg2);
87541     } catch (std::out_of_range& e) {
87542       {
87543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87544       };
87545     } catch (std::exception& e) {
87546       {
87547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87548       };
87549     } catch (Dali::DaliException e) {
87550       {
87551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87552       };
87553     } catch (...) {
87554       {
87555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87556       };
87557     }
87558   }
87559
87560   jresult = (void *)result;
87561   return jresult;
87562 }
87563
87564
87565 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider(void * jarg1) {
87566   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
87567
87568   arg1 = (Dali::Toolkit::Slider *)jarg1;
87569   {
87570     try {
87571       delete arg1;
87572     } catch (std::out_of_range& e) {
87573       {
87574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87575       };
87576     } catch (std::exception& e) {
87577       {
87578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87579       };
87580     } catch (Dali::DaliException e) {
87581       {
87582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87583       };
87584     } catch (...) {
87585       {
87586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87587       };
87588     }
87589   }
87590
87591 }
87592
87593
87594 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_DownCast(void * jarg1) {
87595   void * jresult ;
87596   Dali::BaseHandle arg1 ;
87597   Dali::BaseHandle *argp1 ;
87598   Dali::Toolkit::Slider result;
87599
87600   argp1 = (Dali::BaseHandle *)jarg1;
87601   if (!argp1) {
87602     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
87603     return 0;
87604   }
87605   arg1 = *argp1;
87606   {
87607     try {
87608       result = Dali::Toolkit::Slider::DownCast(arg1);
87609     } catch (std::out_of_range& e) {
87610       {
87611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87612       };
87613     } catch (std::exception& e) {
87614       {
87615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87616       };
87617     } catch (Dali::DaliException e) {
87618       {
87619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87620       };
87621     } catch (...) {
87622       {
87623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87624       };
87625     }
87626   }
87627
87628   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
87629   return jresult;
87630 }
87631
87632
87633 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_ValueChangedSignal(void * jarg1) {
87634   void * jresult ;
87635   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
87636   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
87637
87638   arg1 = (Dali::Toolkit::Slider *)jarg1;
87639   {
87640     try {
87641       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
87642     } catch (std::out_of_range& e) {
87643       {
87644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87645       };
87646     } catch (std::exception& e) {
87647       {
87648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87649       };
87650     } catch (Dali::DaliException e) {
87651       {
87652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87653       };
87654     } catch (...) {
87655       {
87656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87657       };
87658     }
87659   }
87660
87661   jresult = (void *)result;
87662   return jresult;
87663 }
87664
87665
87666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_SlidingFinishedSignal(void * jarg1) {
87667   void * jresult ;
87668   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
87669   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
87670
87671   arg1 = (Dali::Toolkit::Slider *)jarg1;
87672   {
87673     try {
87674       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->SlidingFinishedSignal();
87675     } catch (std::out_of_range& e) {
87676       {
87677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87678       };
87679     } catch (std::exception& e) {
87680       {
87681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87682       };
87683     } catch (Dali::DaliException e) {
87684       {
87685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87686       };
87687     } catch (...) {
87688       {
87689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87690       };
87691     }
87692   }
87693
87694   jresult = (void *)result;
87695   return jresult;
87696 }
87697
87698
87699 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_MarkReachedSignal(void * jarg1) {
87700   void * jresult ;
87701   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
87702   Dali::Toolkit::Slider::MarkReachedSignalType *result = 0 ;
87703
87704   arg1 = (Dali::Toolkit::Slider *)jarg1;
87705   {
87706     try {
87707       result = (Dali::Toolkit::Slider::MarkReachedSignalType *) &(arg1)->MarkReachedSignal();
87708     } catch (std::out_of_range& e) {
87709       {
87710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87711       };
87712     } catch (std::exception& e) {
87713       {
87714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87715       };
87716     } catch (Dali::DaliException e) {
87717       {
87718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87719       };
87720     } catch (...) {
87721       {
87722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87723       };
87724     }
87725   }
87726
87727   jresult = (void *)result;
87728   return jresult;
87729 }
87730
87731
87732 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VIDEO_get() {
87733   int jresult ;
87734   int result;
87735
87736   result = (int)Dali::Toolkit::VideoView::Property::VIDEO;
87737   jresult = (int)result;
87738   return jresult;
87739 }
87740
87741
87742 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_LOOPING_get() {
87743   int jresult ;
87744   int result;
87745
87746   result = (int)Dali::Toolkit::VideoView::Property::LOOPING;
87747   jresult = (int)result;
87748   return jresult;
87749 }
87750
87751
87752 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_MUTED_get() {
87753   int jresult ;
87754   int result;
87755
87756   result = (int)Dali::Toolkit::VideoView::Property::MUTED;
87757   jresult = (int)result;
87758   return jresult;
87759 }
87760
87761
87762 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VOLUME_get() {
87763   int jresult ;
87764   int result;
87765
87766   result = (int)Dali::Toolkit::VideoView::Property::VOLUME;
87767   jresult = (int)result;
87768   return jresult;
87769 }
87770
87771
87772 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_UNDERLAY_get() {
87773   int result;
87774
87775   result = (int)Dali::Toolkit::VideoView::Property::UNDERLAY;
87776
87777   return result;
87778 }
87779
87780
87781 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView_Property() {
87782   void * jresult ;
87783   Dali::Toolkit::VideoView::Property *result = 0 ;
87784
87785   {
87786     try {
87787       result = (Dali::Toolkit::VideoView::Property *)new Dali::Toolkit::VideoView::Property();
87788     } catch (std::out_of_range& e) {
87789       {
87790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87791       };
87792     } catch (std::exception& e) {
87793       {
87794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87795       };
87796     } catch (Dali::DaliException e) {
87797       {
87798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87799       };
87800     } catch (...) {
87801       {
87802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87803       };
87804     }
87805   }
87806
87807   jresult = (void *)result;
87808   return jresult;
87809 }
87810
87811
87812 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView_Property(void * jarg1) {
87813   Dali::Toolkit::VideoView::Property *arg1 = (Dali::Toolkit::VideoView::Property *) 0 ;
87814
87815   arg1 = (Dali::Toolkit::VideoView::Property *)jarg1;
87816   {
87817     try {
87818       delete arg1;
87819     } catch (std::out_of_range& e) {
87820       {
87821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87822       };
87823     } catch (std::exception& e) {
87824       {
87825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87826       };
87827     } catch (Dali::DaliException e) {
87828       {
87829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87830       };
87831     } catch (...) {
87832       {
87833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87834       };
87835     }
87836   }
87837
87838 }
87839
87840
87841 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_0() {
87842   void * jresult ;
87843   Dali::Toolkit::VideoView result;
87844
87845   {
87846     try {
87847       result = Dali::Toolkit::VideoView::New();
87848     } catch (std::out_of_range& e) {
87849       {
87850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87851       };
87852     } catch (std::exception& e) {
87853       {
87854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87855       };
87856     } catch (Dali::DaliException e) {
87857       {
87858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87859       };
87860     } catch (...) {
87861       {
87862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87863       };
87864     }
87865   }
87866
87867   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
87868   return jresult;
87869 }
87870
87871
87872 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_1(char * jarg1) {
87873   void * jresult ;
87874   std::string *arg1 = 0 ;
87875   Dali::Toolkit::VideoView result;
87876
87877   if (!jarg1) {
87878     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
87879     return 0;
87880   }
87881   std::string arg1_str(jarg1);
87882   arg1 = &arg1_str;
87883   {
87884     try {
87885       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1);
87886     } catch (std::out_of_range& e) {
87887       {
87888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87889       };
87890     } catch (std::exception& e) {
87891       {
87892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87893       };
87894     } catch (Dali::DaliException e) {
87895       {
87896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87897       };
87898     } catch (...) {
87899       {
87900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87901       };
87902     }
87903   }
87904
87905   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
87906
87907   //argout typemap for const std::string&
87908
87909   return jresult;
87910 }
87911
87912
87913 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_0() {
87914   void * jresult ;
87915   Dali::Toolkit::VideoView *result = 0 ;
87916
87917   {
87918     try {
87919       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView();
87920     } catch (std::out_of_range& e) {
87921       {
87922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87923       };
87924     } catch (std::exception& e) {
87925       {
87926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87927       };
87928     } catch (Dali::DaliException e) {
87929       {
87930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87931       };
87932     } catch (...) {
87933       {
87934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87935       };
87936     }
87937   }
87938
87939   jresult = (void *)result;
87940   return jresult;
87941 }
87942
87943
87944 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView(void * jarg1) {
87945   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87946
87947   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87948   {
87949     try {
87950       delete arg1;
87951     } catch (std::out_of_range& e) {
87952       {
87953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87954       };
87955     } catch (std::exception& e) {
87956       {
87957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87958       };
87959     } catch (Dali::DaliException e) {
87960       {
87961         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87962       };
87963     } catch (...) {
87964       {
87965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87966       };
87967     }
87968   }
87969
87970 }
87971
87972
87973 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_1(void * jarg1) {
87974   void * jresult ;
87975   Dali::Toolkit::VideoView *arg1 = 0 ;
87976   Dali::Toolkit::VideoView *result = 0 ;
87977
87978   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87979   if (!arg1) {
87980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
87981     return 0;
87982   }
87983   {
87984     try {
87985       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView((Dali::Toolkit::VideoView const &)*arg1);
87986     } catch (std::out_of_range& e) {
87987       {
87988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87989       };
87990     } catch (std::exception& e) {
87991       {
87992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87993       };
87994     } catch (Dali::DaliException e) {
87995       {
87996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87997       };
87998     } catch (...) {
87999       {
88000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88001       };
88002     }
88003   }
88004
88005   jresult = (void *)result;
88006   return jresult;
88007 }
88008
88009
88010 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_Assign(void * jarg1, void * jarg2) {
88011   void * jresult ;
88012   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
88013   Dali::Toolkit::VideoView *arg2 = 0 ;
88014   Dali::Toolkit::VideoView *result = 0 ;
88015
88016   arg1 = (Dali::Toolkit::VideoView *)jarg1;
88017   arg2 = (Dali::Toolkit::VideoView *)jarg2;
88018   if (!arg2) {
88019     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
88020     return 0;
88021   }
88022   {
88023     try {
88024       result = (Dali::Toolkit::VideoView *) &(arg1)->operator =((Dali::Toolkit::VideoView const &)*arg2);
88025     } catch (std::out_of_range& e) {
88026       {
88027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88028       };
88029     } catch (std::exception& e) {
88030       {
88031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88032       };
88033     } catch (Dali::DaliException e) {
88034       {
88035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88036       };
88037     } catch (...) {
88038       {
88039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88040       };
88041     }
88042   }
88043
88044   jresult = (void *)result;
88045   return jresult;
88046 }
88047
88048
88049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_DownCast(void * jarg1) {
88050   void * jresult ;
88051   Dali::BaseHandle arg1 ;
88052   Dali::BaseHandle *argp1 ;
88053   Dali::Toolkit::VideoView result;
88054
88055   argp1 = (Dali::BaseHandle *)jarg1;
88056   if (!argp1) {
88057     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
88058     return 0;
88059   }
88060   arg1 = *argp1;
88061   {
88062     try {
88063       result = Dali::Toolkit::VideoView::DownCast(arg1);
88064     } catch (std::out_of_range& e) {
88065       {
88066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88067       };
88068     } catch (std::exception& e) {
88069       {
88070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88071       };
88072     } catch (Dali::DaliException e) {
88073       {
88074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88075       };
88076     } catch (...) {
88077       {
88078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88079       };
88080     }
88081   }
88082
88083   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
88084   return jresult;
88085 }
88086
88087
88088 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Play(void * jarg1) {
88089   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
88090
88091   arg1 = (Dali::Toolkit::VideoView *)jarg1;
88092   {
88093     try {
88094       (arg1)->Play();
88095     } catch (std::out_of_range& e) {
88096       {
88097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88098       };
88099     } catch (std::exception& e) {
88100       {
88101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88102       };
88103     } catch (Dali::DaliException e) {
88104       {
88105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88106       };
88107     } catch (...) {
88108       {
88109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88110       };
88111     }
88112   }
88113
88114 }
88115
88116
88117 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Pause(void * jarg1) {
88118   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
88119
88120   arg1 = (Dali::Toolkit::VideoView *)jarg1;
88121   {
88122     try {
88123       (arg1)->Pause();
88124     } catch (std::out_of_range& e) {
88125       {
88126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88127       };
88128     } catch (std::exception& e) {
88129       {
88130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88131       };
88132     } catch (Dali::DaliException e) {
88133       {
88134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88135       };
88136     } catch (...) {
88137       {
88138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88139       };
88140     }
88141   }
88142
88143 }
88144
88145
88146 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Stop(void * jarg1) {
88147   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
88148
88149   arg1 = (Dali::Toolkit::VideoView *)jarg1;
88150   {
88151     try {
88152       (arg1)->Stop();
88153     } catch (std::out_of_range& e) {
88154       {
88155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88156       };
88157     } catch (std::exception& e) {
88158       {
88159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88160       };
88161     } catch (Dali::DaliException e) {
88162       {
88163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88164       };
88165     } catch (...) {
88166       {
88167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88168       };
88169     }
88170   }
88171
88172 }
88173
88174
88175 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Forward(void * jarg1, int jarg2) {
88176   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
88177   int arg2 ;
88178
88179   arg1 = (Dali::Toolkit::VideoView *)jarg1;
88180   arg2 = (int)jarg2;
88181   {
88182     try {
88183       (arg1)->Forward(arg2);
88184     } catch (std::out_of_range& e) {
88185       {
88186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88187       };
88188     } catch (std::exception& e) {
88189       {
88190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88191       };
88192     } catch (Dali::DaliException e) {
88193       {
88194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88195       };
88196     } catch (...) {
88197       {
88198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88199       };
88200     }
88201   }
88202
88203 }
88204
88205
88206 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Backward(void * jarg1, int jarg2) {
88207   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
88208   int arg2 ;
88209
88210   arg1 = (Dali::Toolkit::VideoView *)jarg1;
88211   arg2 = (int)jarg2;
88212   {
88213     try {
88214       (arg1)->Backward(arg2);
88215     } catch (std::out_of_range& e) {
88216       {
88217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88218       };
88219     } catch (std::exception& e) {
88220       {
88221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88222       };
88223     } catch (Dali::DaliException e) {
88224       {
88225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88226       };
88227     } catch (...) {
88228       {
88229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88230       };
88231     }
88232   }
88233
88234 }
88235
88236
88237 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_FinishedSignal(void * jarg1) {
88238   void * jresult ;
88239   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
88240   Dali::Toolkit::VideoView::VideoViewSignalType *result = 0 ;
88241
88242   arg1 = (Dali::Toolkit::VideoView *)jarg1;
88243   {
88244     try {
88245       result = (Dali::Toolkit::VideoView::VideoViewSignalType *) &(arg1)->FinishedSignal();
88246     } catch (std::out_of_range& e) {
88247       {
88248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88249       };
88250     } catch (std::exception& e) {
88251       {
88252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88253       };
88254     } catch (Dali::DaliException e) {
88255       {
88256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88257       };
88258     } catch (...) {
88259       {
88260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88261       };
88262     }
88263   }
88264
88265   jresult = (void *)result;
88266   return jresult;
88267 }
88268
88269
88270 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TITLE_get() {
88271   int jresult ;
88272   int result;
88273
88274   result = (int)Dali::Toolkit::Popup::Property::TITLE;
88275   jresult = (int)result;
88276   return jresult;
88277 }
88278
88279
88280 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTENT_get() {
88281   int jresult ;
88282   int result;
88283
88284   result = (int)Dali::Toolkit::Popup::Property::CONTENT;
88285   jresult = (int)result;
88286   return jresult;
88287 }
88288
88289
88290 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_FOOTER_get() {
88291   int jresult ;
88292   int result;
88293
88294   result = (int)Dali::Toolkit::Popup::Property::FOOTER;
88295   jresult = (int)result;
88296   return jresult;
88297 }
88298
88299
88300 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_DISPLAY_STATE_get() {
88301   int jresult ;
88302   int result;
88303
88304   result = (int)Dali::Toolkit::Popup::Property::DISPLAY_STATE;
88305   jresult = (int)result;
88306   return jresult;
88307 }
88308
88309
88310 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TOUCH_TRANSPARENT_get() {
88311   int jresult ;
88312   int result;
88313
88314   result = (int)Dali::Toolkit::Popup::Property::TOUCH_TRANSPARENT;
88315   jresult = (int)result;
88316   return jresult;
88317 }
88318
88319
88320 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_VISIBILITY_get() {
88321   int jresult ;
88322   int result;
88323
88324   result = (int)Dali::Toolkit::Popup::Property::TAIL_VISIBILITY;
88325   jresult = (int)result;
88326   return jresult;
88327 }
88328
88329
88330 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_POSITION_get() {
88331   int jresult ;
88332   int result;
88333
88334   result = (int)Dali::Toolkit::Popup::Property::TAIL_POSITION;
88335   jresult = (int)result;
88336   return jresult;
88337 }
88338
88339
88340 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTEXTUAL_MODE_get() {
88341   int jresult ;
88342   int result;
88343
88344   result = (int)Dali::Toolkit::Popup::Property::CONTEXTUAL_MODE;
88345   jresult = (int)result;
88346   return jresult;
88347 }
88348
88349
88350 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_DURATION_get() {
88351   int jresult ;
88352   int result;
88353
88354   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_DURATION;
88355   jresult = (int)result;
88356   return jresult;
88357 }
88358
88359
88360 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_MODE_get() {
88361   int jresult ;
88362   int result;
88363
88364   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_MODE;
88365   jresult = (int)result;
88366   return jresult;
88367 }
88368
88369
88370 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ENTRY_ANIMATION_get() {
88371   int jresult ;
88372   int result;
88373
88374   result = (int)Dali::Toolkit::Popup::Property::ENTRY_ANIMATION;
88375   jresult = (int)result;
88376   return jresult;
88377 }
88378
88379
88380 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_EXIT_ANIMATION_get() {
88381   int jresult ;
88382   int result;
88383
88384   result = (int)Dali::Toolkit::Popup::Property::EXIT_ANIMATION;
88385   jresult = (int)result;
88386   return jresult;
88387 }
88388
88389
88390 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_AUTO_HIDE_DELAY_get() {
88391   int jresult ;
88392   int result;
88393
88394   result = (int)Dali::Toolkit::Popup::Property::AUTO_HIDE_DELAY;
88395   jresult = (int)result;
88396   return jresult;
88397 }
88398
88399
88400 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_ENABLED_get() {
88401   int jresult ;
88402   int result;
88403
88404   result = (int)Dali::Toolkit::Popup::Property::BACKING_ENABLED;
88405   jresult = (int)result;
88406   return jresult;
88407 }
88408
88409
88410 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_COLOR_get() {
88411   int jresult ;
88412   int result;
88413
88414   result = (int)Dali::Toolkit::Popup::Property::BACKING_COLOR;
88415   jresult = (int)result;
88416   return jresult;
88417 }
88418
88419
88420 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_IMAGE_get() {
88421   int jresult ;
88422   int result;
88423
88424   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_IMAGE;
88425   jresult = (int)result;
88426   return jresult;
88427 }
88428
88429
88430 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_BORDER_get() {
88431   int jresult ;
88432   int result;
88433
88434   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_BORDER;
88435   jresult = (int)result;
88436   return jresult;
88437 }
88438
88439
88440 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_UP_IMAGE_get() {
88441   int jresult ;
88442   int result;
88443
88444   result = (int)Dali::Toolkit::Popup::Property::TAIL_UP_IMAGE;
88445   jresult = (int)result;
88446   return jresult;
88447 }
88448
88449
88450 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_DOWN_IMAGE_get() {
88451   int jresult ;
88452   int result;
88453
88454   result = (int)Dali::Toolkit::Popup::Property::TAIL_DOWN_IMAGE;
88455   jresult = (int)result;
88456   return jresult;
88457 }
88458
88459
88460 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_LEFT_IMAGE_get() {
88461   int jresult ;
88462   int result;
88463
88464   result = (int)Dali::Toolkit::Popup::Property::TAIL_LEFT_IMAGE;
88465   jresult = (int)result;
88466   return jresult;
88467 }
88468
88469
88470 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_RIGHT_IMAGE_get() {
88471   int jresult ;
88472   int result;
88473
88474   result = (int)Dali::Toolkit::Popup::Property::TAIL_RIGHT_IMAGE;
88475   jresult = (int)result;
88476   return jresult;
88477 }
88478
88479
88480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup_Property() {
88481   void * jresult ;
88482   Dali::Toolkit::Popup::Property *result = 0 ;
88483
88484   {
88485     try {
88486       result = (Dali::Toolkit::Popup::Property *)new Dali::Toolkit::Popup::Property();
88487     } catch (std::out_of_range& e) {
88488       {
88489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88490       };
88491     } catch (std::exception& e) {
88492       {
88493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88494       };
88495     } catch (Dali::DaliException e) {
88496       {
88497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88498       };
88499     } catch (...) {
88500       {
88501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88502       };
88503     }
88504   }
88505
88506   jresult = (void *)result;
88507   return jresult;
88508 }
88509
88510
88511 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup_Property(void * jarg1) {
88512   Dali::Toolkit::Popup::Property *arg1 = (Dali::Toolkit::Popup::Property *) 0 ;
88513
88514   arg1 = (Dali::Toolkit::Popup::Property *)jarg1;
88515   {
88516     try {
88517       delete arg1;
88518     } catch (std::out_of_range& e) {
88519       {
88520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88521       };
88522     } catch (std::exception& e) {
88523       {
88524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88525       };
88526     } catch (Dali::DaliException e) {
88527       {
88528         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88529       };
88530     } catch (...) {
88531       {
88532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88533       };
88534     }
88535   }
88536
88537 }
88538
88539
88540 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_0() {
88541   void * jresult ;
88542   Dali::Toolkit::Popup *result = 0 ;
88543
88544   {
88545     try {
88546       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup();
88547     } catch (std::out_of_range& e) {
88548       {
88549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88550       };
88551     } catch (std::exception& e) {
88552       {
88553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88554       };
88555     } catch (Dali::DaliException e) {
88556       {
88557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88558       };
88559     } catch (...) {
88560       {
88561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88562       };
88563     }
88564   }
88565
88566   jresult = (void *)result;
88567   return jresult;
88568 }
88569
88570
88571 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_New() {
88572   void * jresult ;
88573   Dali::Toolkit::Popup result;
88574
88575   {
88576     try {
88577       result = Dali::Toolkit::Popup::New();
88578     } catch (std::out_of_range& e) {
88579       {
88580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88581       };
88582     } catch (std::exception& e) {
88583       {
88584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88585       };
88586     } catch (Dali::DaliException e) {
88587       {
88588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88589       };
88590     } catch (...) {
88591       {
88592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88593       };
88594     }
88595   }
88596
88597   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
88598   return jresult;
88599 }
88600
88601
88602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup(void * jarg1) {
88603   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88604
88605   arg1 = (Dali::Toolkit::Popup *)jarg1;
88606   {
88607     try {
88608       delete arg1;
88609     } catch (std::out_of_range& e) {
88610       {
88611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88612       };
88613     } catch (std::exception& e) {
88614       {
88615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88616       };
88617     } catch (Dali::DaliException e) {
88618       {
88619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88620       };
88621     } catch (...) {
88622       {
88623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88624       };
88625     }
88626   }
88627
88628 }
88629
88630
88631 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_1(void * jarg1) {
88632   void * jresult ;
88633   Dali::Toolkit::Popup *arg1 = 0 ;
88634   Dali::Toolkit::Popup *result = 0 ;
88635
88636   arg1 = (Dali::Toolkit::Popup *)jarg1;
88637   if (!arg1) {
88638     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
88639     return 0;
88640   }
88641   {
88642     try {
88643       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup((Dali::Toolkit::Popup const &)*arg1);
88644     } catch (std::out_of_range& e) {
88645       {
88646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88647       };
88648     } catch (std::exception& e) {
88649       {
88650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88651       };
88652     } catch (Dali::DaliException e) {
88653       {
88654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88655       };
88656     } catch (...) {
88657       {
88658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88659       };
88660     }
88661   }
88662
88663   jresult = (void *)result;
88664   return jresult;
88665 }
88666
88667
88668 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_Assign(void * jarg1, void * jarg2) {
88669   void * jresult ;
88670   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88671   Dali::Toolkit::Popup *arg2 = 0 ;
88672   Dali::Toolkit::Popup *result = 0 ;
88673
88674   arg1 = (Dali::Toolkit::Popup *)jarg1;
88675   arg2 = (Dali::Toolkit::Popup *)jarg2;
88676   if (!arg2) {
88677     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
88678     return 0;
88679   }
88680   {
88681     try {
88682       result = (Dali::Toolkit::Popup *) &(arg1)->operator =((Dali::Toolkit::Popup const &)*arg2);
88683     } catch (std::out_of_range& e) {
88684       {
88685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88686       };
88687     } catch (std::exception& e) {
88688       {
88689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88690       };
88691     } catch (Dali::DaliException e) {
88692       {
88693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88694       };
88695     } catch (...) {
88696       {
88697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88698       };
88699     }
88700   }
88701
88702   jresult = (void *)result;
88703   return jresult;
88704 }
88705
88706
88707 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_DownCast(void * jarg1) {
88708   void * jresult ;
88709   Dali::BaseHandle arg1 ;
88710   Dali::BaseHandle *argp1 ;
88711   Dali::Toolkit::Popup result;
88712
88713   argp1 = (Dali::BaseHandle *)jarg1;
88714   if (!argp1) {
88715     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
88716     return 0;
88717   }
88718   arg1 = *argp1;
88719   {
88720     try {
88721       result = Dali::Toolkit::Popup::DownCast(arg1);
88722     } catch (std::out_of_range& e) {
88723       {
88724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88725       };
88726     } catch (std::exception& e) {
88727       {
88728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88729       };
88730     } catch (Dali::DaliException e) {
88731       {
88732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88733       };
88734     } catch (...) {
88735       {
88736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88737       };
88738     }
88739   }
88740
88741   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
88742   return jresult;
88743 }
88744
88745
88746 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetTitle(void * jarg1, void * jarg2) {
88747   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88748   Dali::Actor arg2 ;
88749   Dali::Actor *argp2 ;
88750
88751   arg1 = (Dali::Toolkit::Popup *)jarg1;
88752   argp2 = (Dali::Actor *)jarg2;
88753   if (!argp2) {
88754     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88755     return ;
88756   }
88757   arg2 = *argp2;
88758   {
88759     try {
88760       (arg1)->SetTitle(arg2);
88761     } catch (std::out_of_range& e) {
88762       {
88763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88764       };
88765     } catch (std::exception& e) {
88766       {
88767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88768       };
88769     } catch (Dali::DaliException e) {
88770       {
88771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88772       };
88773     } catch (...) {
88774       {
88775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88776       };
88777     }
88778   }
88779
88780 }
88781
88782
88783 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetTitle(void * jarg1) {
88784   void * jresult ;
88785   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88786   Dali::Actor result;
88787
88788   arg1 = (Dali::Toolkit::Popup *)jarg1;
88789   {
88790     try {
88791       result = ((Dali::Toolkit::Popup const *)arg1)->GetTitle();
88792     } catch (std::out_of_range& e) {
88793       {
88794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88795       };
88796     } catch (std::exception& e) {
88797       {
88798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88799       };
88800     } catch (Dali::DaliException e) {
88801       {
88802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88803       };
88804     } catch (...) {
88805       {
88806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88807       };
88808     }
88809   }
88810
88811   jresult = new Dali::Actor((const Dali::Actor &)result);
88812   return jresult;
88813 }
88814
88815
88816 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetContent(void * jarg1, void * jarg2) {
88817   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88818   Dali::Actor arg2 ;
88819   Dali::Actor *argp2 ;
88820
88821   arg1 = (Dali::Toolkit::Popup *)jarg1;
88822   argp2 = (Dali::Actor *)jarg2;
88823   if (!argp2) {
88824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88825     return ;
88826   }
88827   arg2 = *argp2;
88828   {
88829     try {
88830       (arg1)->SetContent(arg2);
88831     } catch (std::out_of_range& e) {
88832       {
88833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88834       };
88835     } catch (std::exception& e) {
88836       {
88837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88838       };
88839     } catch (Dali::DaliException e) {
88840       {
88841         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88842       };
88843     } catch (...) {
88844       {
88845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88846       };
88847     }
88848   }
88849
88850 }
88851
88852
88853 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetContent(void * jarg1) {
88854   void * jresult ;
88855   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88856   Dali::Actor result;
88857
88858   arg1 = (Dali::Toolkit::Popup *)jarg1;
88859   {
88860     try {
88861       result = ((Dali::Toolkit::Popup const *)arg1)->GetContent();
88862     } catch (std::out_of_range& e) {
88863       {
88864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88865       };
88866     } catch (std::exception& e) {
88867       {
88868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88869       };
88870     } catch (Dali::DaliException e) {
88871       {
88872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88873       };
88874     } catch (...) {
88875       {
88876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88877       };
88878     }
88879   }
88880
88881   jresult = new Dali::Actor((const Dali::Actor &)result);
88882   return jresult;
88883 }
88884
88885
88886 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetFooter(void * jarg1, void * jarg2) {
88887   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88888   Dali::Actor arg2 ;
88889   Dali::Actor *argp2 ;
88890
88891   arg1 = (Dali::Toolkit::Popup *)jarg1;
88892   argp2 = (Dali::Actor *)jarg2;
88893   if (!argp2) {
88894     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88895     return ;
88896   }
88897   arg2 = *argp2;
88898   {
88899     try {
88900       (arg1)->SetFooter(arg2);
88901     } catch (std::out_of_range& e) {
88902       {
88903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88904       };
88905     } catch (std::exception& e) {
88906       {
88907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88908       };
88909     } catch (Dali::DaliException e) {
88910       {
88911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88912       };
88913     } catch (...) {
88914       {
88915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88916       };
88917     }
88918   }
88919
88920 }
88921
88922
88923 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetFooter(void * jarg1) {
88924   void * jresult ;
88925   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88926   Dali::Actor result;
88927
88928   arg1 = (Dali::Toolkit::Popup *)jarg1;
88929   {
88930     try {
88931       result = ((Dali::Toolkit::Popup const *)arg1)->GetFooter();
88932     } catch (std::out_of_range& e) {
88933       {
88934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88935       };
88936     } catch (std::exception& e) {
88937       {
88938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88939       };
88940     } catch (Dali::DaliException e) {
88941       {
88942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88943       };
88944     } catch (...) {
88945       {
88946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88947       };
88948     }
88949   }
88950
88951   jresult = new Dali::Actor((const Dali::Actor &)result);
88952   return jresult;
88953 }
88954
88955
88956 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetDisplayState(void * jarg1, int jarg2) {
88957   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88958   Dali::Toolkit::Popup::DisplayState arg2 ;
88959
88960   arg1 = (Dali::Toolkit::Popup *)jarg1;
88961   arg2 = (Dali::Toolkit::Popup::DisplayState)jarg2;
88962   {
88963     try {
88964       (arg1)->SetDisplayState(arg2);
88965     } catch (std::out_of_range& e) {
88966       {
88967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88968       };
88969     } catch (std::exception& e) {
88970       {
88971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88972       };
88973     } catch (Dali::DaliException e) {
88974       {
88975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88976       };
88977     } catch (...) {
88978       {
88979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88980       };
88981     }
88982   }
88983
88984 }
88985
88986
88987 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_GetDisplayState(void * jarg1) {
88988   int jresult ;
88989   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88990   Dali::Toolkit::Popup::DisplayState result;
88991
88992   arg1 = (Dali::Toolkit::Popup *)jarg1;
88993   {
88994     try {
88995       result = (Dali::Toolkit::Popup::DisplayState)((Dali::Toolkit::Popup const *)arg1)->GetDisplayState();
88996     } catch (std::out_of_range& e) {
88997       {
88998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88999       };
89000     } catch (std::exception& e) {
89001       {
89002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89003       };
89004     } catch (Dali::DaliException e) {
89005       {
89006         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89007       };
89008     } catch (...) {
89009       {
89010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89011       };
89012     }
89013   }
89014
89015   jresult = (int)result;
89016   return jresult;
89017 }
89018
89019
89020 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_OutsideTouchedSignal(void * jarg1) {
89021   void * jresult ;
89022   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
89023   Dali::Toolkit::Popup::TouchedOutsideSignalType *result = 0 ;
89024
89025   arg1 = (Dali::Toolkit::Popup *)jarg1;
89026   {
89027     try {
89028       result = (Dali::Toolkit::Popup::TouchedOutsideSignalType *) &(arg1)->OutsideTouchedSignal();
89029     } catch (std::out_of_range& e) {
89030       {
89031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89032       };
89033     } catch (std::exception& e) {
89034       {
89035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89036       };
89037     } catch (Dali::DaliException e) {
89038       {
89039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89040       };
89041     } catch (...) {
89042       {
89043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89044       };
89045     }
89046   }
89047
89048   jresult = (void *)result;
89049   return jresult;
89050 }
89051
89052
89053 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShowingSignal(void * jarg1) {
89054   void * jresult ;
89055   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
89056   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
89057
89058   arg1 = (Dali::Toolkit::Popup *)jarg1;
89059   {
89060     try {
89061       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShowingSignal();
89062     } catch (std::out_of_range& e) {
89063       {
89064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89065       };
89066     } catch (std::exception& e) {
89067       {
89068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89069       };
89070     } catch (Dali::DaliException e) {
89071       {
89072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89073       };
89074     } catch (...) {
89075       {
89076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89077       };
89078     }
89079   }
89080
89081   jresult = (void *)result;
89082   return jresult;
89083 }
89084
89085
89086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShownSignal(void * jarg1) {
89087   void * jresult ;
89088   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
89089   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
89090
89091   arg1 = (Dali::Toolkit::Popup *)jarg1;
89092   {
89093     try {
89094       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShownSignal();
89095     } catch (std::out_of_range& e) {
89096       {
89097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89098       };
89099     } catch (std::exception& e) {
89100       {
89101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89102       };
89103     } catch (Dali::DaliException e) {
89104       {
89105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89106       };
89107     } catch (...) {
89108       {
89109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89110       };
89111     }
89112   }
89113
89114   jresult = (void *)result;
89115   return jresult;
89116 }
89117
89118
89119 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HidingSignal(void * jarg1) {
89120   void * jresult ;
89121   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
89122   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
89123
89124   arg1 = (Dali::Toolkit::Popup *)jarg1;
89125   {
89126     try {
89127       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HidingSignal();
89128     } catch (std::out_of_range& e) {
89129       {
89130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89131       };
89132     } catch (std::exception& e) {
89133       {
89134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89135       };
89136     } catch (Dali::DaliException e) {
89137       {
89138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89139       };
89140     } catch (...) {
89141       {
89142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89143       };
89144     }
89145   }
89146
89147   jresult = (void *)result;
89148   return jresult;
89149 }
89150
89151
89152 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HiddenSignal(void * jarg1) {
89153   void * jresult ;
89154   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
89155   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
89156
89157   arg1 = (Dali::Toolkit::Popup *)jarg1;
89158   {
89159     try {
89160       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HiddenSignal();
89161     } catch (std::out_of_range& e) {
89162       {
89163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89164       };
89165     } catch (std::exception& e) {
89166       {
89167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89168       };
89169     } catch (Dali::DaliException e) {
89170       {
89171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89172       };
89173     } catch (...) {
89174       {
89175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89176       };
89177     }
89178   }
89179
89180   jresult = (void *)result;
89181   return jresult;
89182 }
89183
89184
89185 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VALUE_get() {
89186   int jresult ;
89187   int result;
89188
89189   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VALUE;
89190   jresult = (int)result;
89191   return jresult;
89192 }
89193
89194
89195 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VALUE_get() {
89196   int jresult ;
89197   int result;
89198
89199   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VALUE;
89200   jresult = (int)result;
89201   return jresult;
89202 }
89203
89204
89205 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_get() {
89206   int jresult ;
89207   int result;
89208
89209   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE;
89210   jresult = (int)result;
89211   return jresult;
89212 }
89213
89214
89215 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_TRACK_VISUAL_get() {
89216   int jresult ;
89217   int result;
89218
89219   result = (int)Dali::Toolkit::ProgressBar::Property::TRACK_VISUAL;
89220   jresult = (int)result;
89221   return jresult;
89222 }
89223
89224
89225 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VISUAL_get() {
89226   int jresult ;
89227   int result;
89228
89229   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VISUAL;
89230   jresult = (int)result;
89231   return jresult;
89232 }
89233
89234
89235 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VISUAL_get() {
89236   int jresult ;
89237   int result;
89238
89239   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL;
89240   jresult = (int)result;
89241   return jresult;
89242 }
89243
89244
89245 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_get() {
89246   int jresult ;
89247   int result;
89248
89249   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL;
89250   jresult = (int)result;
89251   return jresult;
89252 }
89253
89254
89255 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_ANIMATION_get() {
89256   int jresult ;
89257   int result;
89258
89259   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL_ANIMATION;
89260   jresult = (int)result;
89261   return jresult;
89262 }
89263
89264
89265 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_LABEL_VISUAL_get() {
89266   int jresult ;
89267   int result;
89268
89269   result = (int)Dali::Toolkit::ProgressBar::Property::LABEL_VISUAL;
89270   jresult = (int)result;
89271   return jresult;
89272 }
89273
89274
89275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar_Property() {
89276   void * jresult ;
89277   Dali::Toolkit::ProgressBar::Property *result = 0 ;
89278
89279   {
89280     try {
89281       result = (Dali::Toolkit::ProgressBar::Property *)new Dali::Toolkit::ProgressBar::Property();
89282     } catch (std::out_of_range& e) {
89283       {
89284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89285       };
89286     } catch (std::exception& e) {
89287       {
89288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89289       };
89290     } catch (Dali::DaliException e) {
89291       {
89292         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89293       };
89294     } catch (...) {
89295       {
89296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89297       };
89298     }
89299   }
89300
89301   jresult = (void *)result;
89302   return jresult;
89303 }
89304
89305
89306 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar_Property(void * jarg1) {
89307   Dali::Toolkit::ProgressBar::Property *arg1 = (Dali::Toolkit::ProgressBar::Property *) 0 ;
89308
89309   arg1 = (Dali::Toolkit::ProgressBar::Property *)jarg1;
89310   {
89311     try {
89312       delete arg1;
89313     } catch (std::out_of_range& e) {
89314       {
89315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89316       };
89317     } catch (std::exception& e) {
89318       {
89319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89320       };
89321     } catch (Dali::DaliException e) {
89322       {
89323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89324       };
89325     } catch (...) {
89326       {
89327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89328       };
89329     }
89330   }
89331
89332 }
89333
89334
89335 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_New() {
89336   void * jresult ;
89337   Dali::Toolkit::ProgressBar result;
89338
89339   {
89340     try {
89341       result = Dali::Toolkit::ProgressBar::New();
89342     } catch (std::out_of_range& e) {
89343       {
89344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89345       };
89346     } catch (std::exception& e) {
89347       {
89348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89349       };
89350     } catch (Dali::DaliException e) {
89351       {
89352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89353       };
89354     } catch (...) {
89355       {
89356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89357       };
89358     }
89359   }
89360
89361   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
89362   return jresult;
89363 }
89364
89365
89366 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_0() {
89367   void * jresult ;
89368   Dali::Toolkit::ProgressBar *result = 0 ;
89369
89370   {
89371     try {
89372       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar();
89373     } catch (std::out_of_range& e) {
89374       {
89375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89376       };
89377     } catch (std::exception& e) {
89378       {
89379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89380       };
89381     } catch (Dali::DaliException e) {
89382       {
89383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89384       };
89385     } catch (...) {
89386       {
89387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89388       };
89389     }
89390   }
89391
89392   jresult = (void *)result;
89393   return jresult;
89394 }
89395
89396
89397 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_1(void * jarg1) {
89398   void * jresult ;
89399   Dali::Toolkit::ProgressBar *arg1 = 0 ;
89400   Dali::Toolkit::ProgressBar *result = 0 ;
89401
89402   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
89403   if (!arg1) {
89404     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
89405     return 0;
89406   }
89407   {
89408     try {
89409       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar((Dali::Toolkit::ProgressBar const &)*arg1);
89410     } catch (std::out_of_range& e) {
89411       {
89412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89413       };
89414     } catch (std::exception& e) {
89415       {
89416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89417       };
89418     } catch (Dali::DaliException e) {
89419       {
89420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89421       };
89422     } catch (...) {
89423       {
89424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89425       };
89426     }
89427   }
89428
89429   jresult = (void *)result;
89430   return jresult;
89431 }
89432
89433
89434 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_Assign(void * jarg1, void * jarg2) {
89435   void * jresult ;
89436   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
89437   Dali::Toolkit::ProgressBar *arg2 = 0 ;
89438   Dali::Toolkit::ProgressBar *result = 0 ;
89439
89440   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
89441   arg2 = (Dali::Toolkit::ProgressBar *)jarg2;
89442   if (!arg2) {
89443     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
89444     return 0;
89445   }
89446   {
89447     try {
89448       result = (Dali::Toolkit::ProgressBar *) &(arg1)->operator =((Dali::Toolkit::ProgressBar const &)*arg2);
89449     } catch (std::out_of_range& e) {
89450       {
89451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89452       };
89453     } catch (std::exception& e) {
89454       {
89455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89456       };
89457     } catch (Dali::DaliException e) {
89458       {
89459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89460       };
89461     } catch (...) {
89462       {
89463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89464       };
89465     }
89466   }
89467
89468   jresult = (void *)result;
89469   return jresult;
89470 }
89471
89472
89473 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar(void * jarg1) {
89474   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
89475
89476   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
89477   {
89478     try {
89479       delete arg1;
89480     } catch (std::out_of_range& e) {
89481       {
89482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89483       };
89484     } catch (std::exception& e) {
89485       {
89486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89487       };
89488     } catch (Dali::DaliException e) {
89489       {
89490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89491       };
89492     } catch (...) {
89493       {
89494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89495       };
89496     }
89497   }
89498
89499 }
89500
89501
89502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_DownCast(void * jarg1) {
89503   void * jresult ;
89504   Dali::BaseHandle arg1 ;
89505   Dali::BaseHandle *argp1 ;
89506   Dali::Toolkit::ProgressBar result;
89507
89508   argp1 = (Dali::BaseHandle *)jarg1;
89509   if (!argp1) {
89510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
89511     return 0;
89512   }
89513   arg1 = *argp1;
89514   {
89515     try {
89516       result = Dali::Toolkit::ProgressBar::DownCast(arg1);
89517     } catch (std::out_of_range& e) {
89518       {
89519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89520       };
89521     } catch (std::exception& e) {
89522       {
89523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89524       };
89525     } catch (Dali::DaliException e) {
89526       {
89527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89528       };
89529     } catch (...) {
89530       {
89531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89532       };
89533     }
89534   }
89535
89536   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
89537   return jresult;
89538 }
89539
89540
89541 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_ValueChangedSignal(void * jarg1) {
89542   void * jresult ;
89543   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
89544   Dali::Toolkit::ProgressBar::ValueChangedSignalType *result = 0 ;
89545
89546   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
89547   {
89548     try {
89549       result = (Dali::Toolkit::ProgressBar::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
89550     } catch (std::out_of_range& e) {
89551       {
89552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89553       };
89554     } catch (std::exception& e) {
89555       {
89556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89557       };
89558     } catch (Dali::DaliException e) {
89559       {
89560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89561       };
89562     } catch (...) {
89563       {
89564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89565       };
89566     }
89567   }
89568
89569   jresult = (void *)result;
89570   return jresult;
89571 }
89572
89573
89574 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_0() {
89575   void * jresult ;
89576   Dali::Toolkit::GaussianBlurView *result = 0 ;
89577
89578   {
89579     try {
89580       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView();
89581     } catch (std::out_of_range& e) {
89582       {
89583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89584       };
89585     } catch (std::exception& e) {
89586       {
89587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89588       };
89589     } catch (Dali::DaliException e) {
89590       {
89591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89592       };
89593     } catch (...) {
89594       {
89595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89596       };
89597     }
89598   }
89599
89600   jresult = (void *)result;
89601   return jresult;
89602 }
89603
89604
89605 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_1(void * jarg1) {
89606   void * jresult ;
89607   Dali::Toolkit::GaussianBlurView *arg1 = 0 ;
89608   Dali::Toolkit::GaussianBlurView *result = 0 ;
89609
89610   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89611   if (!arg1) {
89612     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
89613     return 0;
89614   }
89615   {
89616     try {
89617       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView((Dali::Toolkit::GaussianBlurView const &)*arg1);
89618     } catch (std::out_of_range& e) {
89619       {
89620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89621       };
89622     } catch (std::exception& e) {
89623       {
89624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89625       };
89626     } catch (Dali::DaliException e) {
89627       {
89628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89629       };
89630     } catch (...) {
89631       {
89632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89633       };
89634     }
89635   }
89636
89637   jresult = (void *)result;
89638   return jresult;
89639 }
89640
89641
89642 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_Assign(void * jarg1, void * jarg2) {
89643   void * jresult ;
89644   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89645   Dali::Toolkit::GaussianBlurView *arg2 = 0 ;
89646   Dali::Toolkit::GaussianBlurView *result = 0 ;
89647
89648   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89649   arg2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
89650   if (!arg2) {
89651     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
89652     return 0;
89653   }
89654   {
89655     try {
89656       result = (Dali::Toolkit::GaussianBlurView *) &(arg1)->operator =((Dali::Toolkit::GaussianBlurView const &)*arg2);
89657     } catch (std::out_of_range& e) {
89658       {
89659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89660       };
89661     } catch (std::exception& e) {
89662       {
89663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89664       };
89665     } catch (Dali::DaliException e) {
89666       {
89667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89668       };
89669     } catch (...) {
89670       {
89671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89672       };
89673     }
89674   }
89675
89676   jresult = (void *)result;
89677   return jresult;
89678 }
89679
89680
89681 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurView(void * jarg1) {
89682   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89683
89684   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89685   {
89686     try {
89687       delete arg1;
89688     } catch (std::out_of_range& e) {
89689       {
89690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89691       };
89692     } catch (std::exception& e) {
89693       {
89694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89695       };
89696     } catch (Dali::DaliException e) {
89697       {
89698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89699       };
89700     } catch (...) {
89701       {
89702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89703       };
89704     }
89705   }
89706
89707 }
89708
89709
89710 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_DownCast(void * jarg1) {
89711   void * jresult ;
89712   Dali::BaseHandle arg1 ;
89713   Dali::BaseHandle *argp1 ;
89714   Dali::Toolkit::GaussianBlurView result;
89715
89716   argp1 = (Dali::BaseHandle *)jarg1;
89717   if (!argp1) {
89718     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
89719     return 0;
89720   }
89721   arg1 = *argp1;
89722   {
89723     try {
89724       result = Dali::Toolkit::GaussianBlurView::DownCast(arg1);
89725     } catch (std::out_of_range& e) {
89726       {
89727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89728       };
89729     } catch (std::exception& e) {
89730       {
89731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89732       };
89733     } catch (Dali::DaliException e) {
89734       {
89735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89736       };
89737     } catch (...) {
89738       {
89739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89740       };
89741     }
89742   }
89743
89744   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
89745   return jresult;
89746 }
89747
89748
89749 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_0() {
89750   void * jresult ;
89751   Dali::Toolkit::GaussianBlurView result;
89752
89753   {
89754     try {
89755       result = Dali::Toolkit::GaussianBlurView::New();
89756     } catch (std::out_of_range& e) {
89757       {
89758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89759       };
89760     } catch (std::exception& e) {
89761       {
89762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89763       };
89764     } catch (Dali::DaliException e) {
89765       {
89766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89767       };
89768     } catch (...) {
89769       {
89770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89771       };
89772     }
89773   }
89774
89775   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
89776   return jresult;
89777 }
89778
89779
89780 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_1(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5, unsigned int jarg6) {
89781   void * jresult ;
89782   unsigned int arg1 ;
89783   float arg2 ;
89784   Dali::Pixel::Format arg3 ;
89785   float arg4 ;
89786   float arg5 ;
89787   bool arg6 ;
89788   Dali::Toolkit::GaussianBlurView result;
89789
89790   arg1 = (unsigned int)jarg1;
89791   arg2 = (float)jarg2;
89792   arg3 = (Dali::Pixel::Format)jarg3;
89793   arg4 = (float)jarg4;
89794   arg5 = (float)jarg5;
89795   arg6 = jarg6 ? true : false;
89796   {
89797     try {
89798       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5,arg6);
89799     } catch (std::out_of_range& e) {
89800       {
89801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89802       };
89803     } catch (std::exception& e) {
89804       {
89805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89806       };
89807     } catch (Dali::DaliException e) {
89808       {
89809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89810       };
89811     } catch (...) {
89812       {
89813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89814       };
89815     }
89816   }
89817
89818   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
89819   return jresult;
89820 }
89821
89822
89823 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_2(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5) {
89824   void * jresult ;
89825   unsigned int arg1 ;
89826   float arg2 ;
89827   Dali::Pixel::Format arg3 ;
89828   float arg4 ;
89829   float arg5 ;
89830   Dali::Toolkit::GaussianBlurView result;
89831
89832   arg1 = (unsigned int)jarg1;
89833   arg2 = (float)jarg2;
89834   arg3 = (Dali::Pixel::Format)jarg3;
89835   arg4 = (float)jarg4;
89836   arg5 = (float)jarg5;
89837   {
89838     try {
89839       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5);
89840     } catch (std::out_of_range& e) {
89841       {
89842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89843       };
89844     } catch (std::exception& e) {
89845       {
89846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89847       };
89848     } catch (Dali::DaliException e) {
89849       {
89850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89851       };
89852     } catch (...) {
89853       {
89854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89855       };
89856     }
89857   }
89858
89859   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
89860   return jresult;
89861 }
89862
89863
89864 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Add(void * jarg1, void * jarg2) {
89865   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89866   Dali::Actor arg2 ;
89867   Dali::Actor *argp2 ;
89868
89869   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89870   argp2 = (Dali::Actor *)jarg2;
89871   if (!argp2) {
89872     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
89873     return ;
89874   }
89875   arg2 = *argp2;
89876   {
89877     try {
89878       (arg1)->Add(arg2);
89879     } catch (std::out_of_range& e) {
89880       {
89881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89882       };
89883     } catch (std::exception& e) {
89884       {
89885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89886       };
89887     } catch (Dali::DaliException e) {
89888       {
89889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89890       };
89891     } catch (...) {
89892       {
89893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89894       };
89895     }
89896   }
89897
89898 }
89899
89900
89901 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Remove(void * jarg1, void * jarg2) {
89902   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89903   Dali::Actor arg2 ;
89904   Dali::Actor *argp2 ;
89905
89906   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89907   argp2 = (Dali::Actor *)jarg2;
89908   if (!argp2) {
89909     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
89910     return ;
89911   }
89912   arg2 = *argp2;
89913   {
89914     try {
89915       (arg1)->Remove(arg2);
89916     } catch (std::out_of_range& e) {
89917       {
89918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89919       };
89920     } catch (std::exception& e) {
89921       {
89922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89923       };
89924     } catch (Dali::DaliException e) {
89925       {
89926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89927       };
89928     } catch (...) {
89929       {
89930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89931       };
89932     }
89933   }
89934
89935 }
89936
89937
89938 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Activate(void * jarg1) {
89939   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89940
89941   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89942   {
89943     try {
89944       (arg1)->Activate();
89945     } catch (std::out_of_range& e) {
89946       {
89947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89948       };
89949     } catch (std::exception& e) {
89950       {
89951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89952       };
89953     } catch (Dali::DaliException e) {
89954       {
89955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89956       };
89957     } catch (...) {
89958       {
89959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89960       };
89961     }
89962   }
89963
89964 }
89965
89966
89967 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_ActivateOnce(void * jarg1) {
89968   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89969
89970   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89971   {
89972     try {
89973       (arg1)->ActivateOnce();
89974     } catch (std::out_of_range& e) {
89975       {
89976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89977       };
89978     } catch (std::exception& e) {
89979       {
89980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89981       };
89982     } catch (Dali::DaliException e) {
89983       {
89984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89985       };
89986     } catch (...) {
89987       {
89988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89989       };
89990     }
89991   }
89992
89993 }
89994
89995
89996 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Deactivate(void * jarg1) {
89997   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89998
89999   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
90000   {
90001     try {
90002       (arg1)->Deactivate();
90003     } catch (std::out_of_range& e) {
90004       {
90005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90006       };
90007     } catch (std::exception& e) {
90008       {
90009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90010       };
90011     } catch (Dali::DaliException e) {
90012       {
90013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90014       };
90015     } catch (...) {
90016       {
90017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90018       };
90019     }
90020   }
90021
90022 }
90023
90024
90025 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetUserImageAndOutputRenderTarget(void * jarg1, void * jarg2, void * jarg3) {
90026   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
90027   Dali::Image arg2 ;
90028   Dali::FrameBufferImage arg3 ;
90029   Dali::Image *argp2 ;
90030   Dali::FrameBufferImage *argp3 ;
90031
90032   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
90033   argp2 = (Dali::Image *)jarg2;
90034   if (!argp2) {
90035     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
90036     return ;
90037   }
90038   arg2 = *argp2;
90039   argp3 = (Dali::FrameBufferImage *)jarg3;
90040   if (!argp3) {
90041     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
90042     return ;
90043   }
90044   arg3 = *argp3;
90045   {
90046     try {
90047       (arg1)->SetUserImageAndOutputRenderTarget(arg2,arg3);
90048     } catch (std::out_of_range& e) {
90049       {
90050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90051       };
90052     } catch (std::exception& e) {
90053       {
90054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90055       };
90056     } catch (Dali::DaliException e) {
90057       {
90058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90059       };
90060     } catch (...) {
90061       {
90062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90063       };
90064     }
90065   }
90066
90067 }
90068
90069
90070 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurStrengthPropertyIndex(void * jarg1) {
90071   int jresult ;
90072   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
90073   Dali::Property::Index result;
90074
90075   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
90076   {
90077     try {
90078       result = (Dali::Property::Index)((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurStrengthPropertyIndex();
90079     } catch (std::out_of_range& e) {
90080       {
90081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90082       };
90083     } catch (std::exception& e) {
90084       {
90085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90086       };
90087     } catch (Dali::DaliException e) {
90088       {
90089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90090       };
90091     } catch (...) {
90092       {
90093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90094       };
90095     }
90096   }
90097
90098   jresult = result;
90099   return jresult;
90100 }
90101
90102
90103 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurredRenderTarget(void * jarg1) {
90104   void * jresult ;
90105   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
90106   Dali::FrameBufferImage result;
90107
90108   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
90109   {
90110     try {
90111       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurredRenderTarget();
90112     } catch (std::out_of_range& e) {
90113       {
90114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90115       };
90116     } catch (std::exception& e) {
90117       {
90118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90119       };
90120     } catch (Dali::DaliException e) {
90121       {
90122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90123       };
90124     } catch (...) {
90125       {
90126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90127       };
90128     }
90129   }
90130
90131   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
90132   return jresult;
90133 }
90134
90135
90136 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetBackgroundColor(void * jarg1, void * jarg2) {
90137   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
90138   Dali::Vector4 *arg2 = 0 ;
90139
90140   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
90141   arg2 = (Dali::Vector4 *)jarg2;
90142   if (!arg2) {
90143     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
90144     return ;
90145   }
90146   {
90147     try {
90148       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
90149     } catch (std::out_of_range& e) {
90150       {
90151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90152       };
90153     } catch (std::exception& e) {
90154       {
90155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90156       };
90157     } catch (Dali::DaliException e) {
90158       {
90159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90160       };
90161     } catch (...) {
90162       {
90163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90164       };
90165     }
90166   }
90167
90168 }
90169
90170
90171 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBackgroundColor(void * jarg1) {
90172   void * jresult ;
90173   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
90174   Dali::Vector4 result;
90175
90176   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
90177   {
90178     try {
90179       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBackgroundColor();
90180     } catch (std::out_of_range& e) {
90181       {
90182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90183       };
90184     } catch (std::exception& e) {
90185       {
90186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90187       };
90188     } catch (Dali::DaliException e) {
90189       {
90190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90191       };
90192     } catch (...) {
90193       {
90194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90195       };
90196     }
90197   }
90198
90199   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
90200   return jresult;
90201 }
90202
90203
90204 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_FinishedSignal(void * jarg1) {
90205   void * jresult ;
90206   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
90207   Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *result = 0 ;
90208
90209   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
90210   {
90211     try {
90212       result = (Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *) &(arg1)->FinishedSignal();
90213     } catch (std::out_of_range& e) {
90214       {
90215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90216       };
90217     } catch (std::exception& e) {
90218       {
90219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90220       };
90221     } catch (Dali::DaliException e) {
90222       {
90223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90224       };
90225     } catch (...) {
90226       {
90227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90228       };
90229     }
90230   }
90231
90232   jresult = (void *)result;
90233   return jresult;
90234 }
90235
90236
90237 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageFactory(void * jarg1) {
90238   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
90239
90240   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
90241   {
90242     try {
90243       delete arg1;
90244     } catch (std::out_of_range& e) {
90245       {
90246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90247       };
90248     } catch (std::exception& e) {
90249       {
90250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90251       };
90252     } catch (Dali::DaliException e) {
90253       {
90254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90255       };
90256     } catch (...) {
90257       {
90258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90259       };
90260     }
90261   }
90262
90263 }
90264
90265
90266 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageFactory_GetNumberOfPages(void * jarg1) {
90267   unsigned int jresult ;
90268   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
90269   unsigned int result;
90270
90271   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
90272   {
90273     try {
90274       result = (unsigned int)(arg1)->GetNumberOfPages();
90275     } catch (std::out_of_range& e) {
90276       {
90277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90278       };
90279     } catch (std::exception& e) {
90280       {
90281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90282       };
90283     } catch (Dali::DaliException e) {
90284       {
90285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90286       };
90287     } catch (...) {
90288       {
90289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90290       };
90291     }
90292   }
90293
90294   jresult = result;
90295   return jresult;
90296 }
90297
90298
90299 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageFactory_NewPage(void * jarg1, unsigned int jarg2) {
90300   void * jresult ;
90301   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
90302   unsigned int arg2 ;
90303   Dali::Texture result;
90304
90305   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
90306   arg2 = (unsigned int)jarg2;
90307   {
90308     try {
90309       result = (arg1)->NewPage(arg2);
90310     } catch (std::out_of_range& e) {
90311       {
90312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90313       };
90314     } catch (std::exception& e) {
90315       {
90316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90317       };
90318     } catch (Dali::DaliException e) {
90319       {
90320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90321       };
90322     } catch (...) {
90323       {
90324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90325       };
90326     }
90327   }
90328
90329   jresult = new Dali::Texture((const Dali::Texture &)result);
90330   return jresult;
90331 }
90332
90333
90334 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_PAGE_SIZE_get() {
90335   int jresult ;
90336   int result;
90337
90338   result = (int)Dali::Toolkit::PageTurnView::Property::PAGE_SIZE;
90339   jresult = (int)result;
90340   return jresult;
90341 }
90342
90343
90344 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_CURRENT_PAGE_ID_get() {
90345   int jresult ;
90346   int result;
90347
90348   result = (int)Dali::Toolkit::PageTurnView::Property::CURRENT_PAGE_ID;
90349   jresult = (int)result;
90350   return jresult;
90351 }
90352
90353
90354 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_SPINE_SHADOW_get() {
90355   int jresult ;
90356   int result;
90357
90358   result = (int)Dali::Toolkit::PageTurnView::Property::SPINE_SHADOW;
90359   jresult = (int)result;
90360   return jresult;
90361 }
90362
90363
90364 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView_Property() {
90365   void * jresult ;
90366   Dali::Toolkit::PageTurnView::Property *result = 0 ;
90367
90368   {
90369     try {
90370       result = (Dali::Toolkit::PageTurnView::Property *)new Dali::Toolkit::PageTurnView::Property();
90371     } catch (std::out_of_range& e) {
90372       {
90373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90374       };
90375     } catch (std::exception& e) {
90376       {
90377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90378       };
90379     } catch (Dali::DaliException e) {
90380       {
90381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90382       };
90383     } catch (...) {
90384       {
90385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90386       };
90387     }
90388   }
90389
90390   jresult = (void *)result;
90391   return jresult;
90392 }
90393
90394
90395 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView_Property(void * jarg1) {
90396   Dali::Toolkit::PageTurnView::Property *arg1 = (Dali::Toolkit::PageTurnView::Property *) 0 ;
90397
90398   arg1 = (Dali::Toolkit::PageTurnView::Property *)jarg1;
90399   {
90400     try {
90401       delete arg1;
90402     } catch (std::out_of_range& e) {
90403       {
90404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90405       };
90406     } catch (std::exception& e) {
90407       {
90408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90409       };
90410     } catch (Dali::DaliException e) {
90411       {
90412         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90413       };
90414     } catch (...) {
90415       {
90416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90417       };
90418     }
90419   }
90420
90421 }
90422
90423
90424 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_0() {
90425   void * jresult ;
90426   Dali::Toolkit::PageTurnView *result = 0 ;
90427
90428   {
90429     try {
90430       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView();
90431     } catch (std::out_of_range& e) {
90432       {
90433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90434       };
90435     } catch (std::exception& e) {
90436       {
90437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90438       };
90439     } catch (Dali::DaliException e) {
90440       {
90441         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90442       };
90443     } catch (...) {
90444       {
90445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90446       };
90447     }
90448   }
90449
90450   jresult = (void *)result;
90451   return jresult;
90452 }
90453
90454
90455 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_1(void * jarg1) {
90456   void * jresult ;
90457   Dali::Toolkit::PageTurnView *arg1 = 0 ;
90458   Dali::Toolkit::PageTurnView *result = 0 ;
90459
90460   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90461   if (!arg1) {
90462     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
90463     return 0;
90464   }
90465   {
90466     try {
90467       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView((Dali::Toolkit::PageTurnView const &)*arg1);
90468     } catch (std::out_of_range& e) {
90469       {
90470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90471       };
90472     } catch (std::exception& e) {
90473       {
90474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90475       };
90476     } catch (Dali::DaliException e) {
90477       {
90478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90479       };
90480     } catch (...) {
90481       {
90482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90483       };
90484     }
90485   }
90486
90487   jresult = (void *)result;
90488   return jresult;
90489 }
90490
90491
90492 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_Assign(void * jarg1, void * jarg2) {
90493   void * jresult ;
90494   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90495   Dali::Toolkit::PageTurnView *arg2 = 0 ;
90496   Dali::Toolkit::PageTurnView *result = 0 ;
90497
90498   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90499   arg2 = (Dali::Toolkit::PageTurnView *)jarg2;
90500   if (!arg2) {
90501     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
90502     return 0;
90503   }
90504   {
90505     try {
90506       result = (Dali::Toolkit::PageTurnView *) &(arg1)->operator =((Dali::Toolkit::PageTurnView const &)*arg2);
90507     } catch (std::out_of_range& e) {
90508       {
90509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90510       };
90511     } catch (std::exception& e) {
90512       {
90513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90514       };
90515     } catch (Dali::DaliException e) {
90516       {
90517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90518       };
90519     } catch (...) {
90520       {
90521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90522       };
90523     }
90524   }
90525
90526   jresult = (void *)result;
90527   return jresult;
90528 }
90529
90530
90531 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView(void * jarg1) {
90532   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90533
90534   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90535   {
90536     try {
90537       delete arg1;
90538     } catch (std::out_of_range& e) {
90539       {
90540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90541       };
90542     } catch (std::exception& e) {
90543       {
90544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90545       };
90546     } catch (Dali::DaliException e) {
90547       {
90548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90549       };
90550     } catch (...) {
90551       {
90552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90553       };
90554     }
90555   }
90556
90557 }
90558
90559
90560 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_DownCast(void * jarg1) {
90561   void * jresult ;
90562   Dali::BaseHandle arg1 ;
90563   Dali::BaseHandle *argp1 ;
90564   Dali::Toolkit::PageTurnView result;
90565
90566   argp1 = (Dali::BaseHandle *)jarg1;
90567   if (!argp1) {
90568     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
90569     return 0;
90570   }
90571   arg1 = *argp1;
90572   {
90573     try {
90574       result = Dali::Toolkit::PageTurnView::DownCast(arg1);
90575     } catch (std::out_of_range& e) {
90576       {
90577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90578       };
90579     } catch (std::exception& e) {
90580       {
90581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90582       };
90583     } catch (Dali::DaliException e) {
90584       {
90585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90586       };
90587     } catch (...) {
90588       {
90589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90590       };
90591     }
90592   }
90593
90594   jresult = new Dali::Toolkit::PageTurnView((const Dali::Toolkit::PageTurnView &)result);
90595   return jresult;
90596 }
90597
90598
90599 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnStartedSignal(void * jarg1) {
90600   void * jresult ;
90601   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90602   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
90603
90604   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90605   {
90606     try {
90607       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnStartedSignal();
90608     } catch (std::out_of_range& e) {
90609       {
90610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90611       };
90612     } catch (std::exception& e) {
90613       {
90614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90615       };
90616     } catch (Dali::DaliException e) {
90617       {
90618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90619       };
90620     } catch (...) {
90621       {
90622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90623       };
90624     }
90625   }
90626
90627   jresult = (void *)result;
90628   return jresult;
90629 }
90630
90631
90632 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnFinishedSignal(void * jarg1) {
90633   void * jresult ;
90634   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90635   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
90636
90637   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90638   {
90639     try {
90640       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnFinishedSignal();
90641     } catch (std::out_of_range& e) {
90642       {
90643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90644       };
90645     } catch (std::exception& e) {
90646       {
90647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90648       };
90649     } catch (Dali::DaliException e) {
90650       {
90651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90652       };
90653     } catch (...) {
90654       {
90655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90656       };
90657     }
90658   }
90659
90660   jresult = (void *)result;
90661   return jresult;
90662 }
90663
90664
90665 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanStartedSignal(void * jarg1) {
90666   void * jresult ;
90667   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90668   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
90669
90670   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90671   {
90672     try {
90673       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanStartedSignal();
90674     } catch (std::out_of_range& e) {
90675       {
90676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90677       };
90678     } catch (std::exception& e) {
90679       {
90680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90681       };
90682     } catch (Dali::DaliException e) {
90683       {
90684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90685       };
90686     } catch (...) {
90687       {
90688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90689       };
90690     }
90691   }
90692
90693   jresult = (void *)result;
90694   return jresult;
90695 }
90696
90697
90698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanFinishedSignal(void * jarg1) {
90699   void * jresult ;
90700   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90701   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
90702
90703   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90704   {
90705     try {
90706       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanFinishedSignal();
90707     } catch (std::out_of_range& e) {
90708       {
90709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90710       };
90711     } catch (std::exception& e) {
90712       {
90713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90714       };
90715     } catch (Dali::DaliException e) {
90716       {
90717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90718       };
90719     } catch (...) {
90720       {
90721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90722       };
90723     }
90724   }
90725
90726   jresult = (void *)result;
90727   return jresult;
90728 }
90729
90730
90731 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_0() {
90732   void * jresult ;
90733   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
90734
90735   {
90736     try {
90737       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView();
90738     } catch (std::out_of_range& e) {
90739       {
90740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90741       };
90742     } catch (std::exception& e) {
90743       {
90744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90745       };
90746     } catch (Dali::DaliException e) {
90747       {
90748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90749       };
90750     } catch (...) {
90751       {
90752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90753       };
90754     }
90755   }
90756
90757   jresult = (void *)result;
90758   return jresult;
90759 }
90760
90761
90762 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_1(void * jarg1) {
90763   void * jresult ;
90764   Dali::Toolkit::PageTurnLandscapeView *arg1 = 0 ;
90765   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
90766
90767   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
90768   if (!arg1) {
90769     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
90770     return 0;
90771   }
90772   {
90773     try {
90774       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView((Dali::Toolkit::PageTurnLandscapeView const &)*arg1);
90775     } catch (std::out_of_range& e) {
90776       {
90777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90778       };
90779     } catch (std::exception& e) {
90780       {
90781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90782       };
90783     } catch (Dali::DaliException e) {
90784       {
90785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90786       };
90787     } catch (...) {
90788       {
90789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90790       };
90791     }
90792   }
90793
90794   jresult = (void *)result;
90795   return jresult;
90796 }
90797
90798
90799 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_Assign(void * jarg1, void * jarg2) {
90800   void * jresult ;
90801   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
90802   Dali::Toolkit::PageTurnLandscapeView *arg2 = 0 ;
90803   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
90804
90805   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
90806   arg2 = (Dali::Toolkit::PageTurnLandscapeView *)jarg2;
90807   if (!arg2) {
90808     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
90809     return 0;
90810   }
90811   {
90812     try {
90813       result = (Dali::Toolkit::PageTurnLandscapeView *) &(arg1)->operator =((Dali::Toolkit::PageTurnLandscapeView const &)*arg2);
90814     } catch (std::out_of_range& e) {
90815       {
90816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90817       };
90818     } catch (std::exception& e) {
90819       {
90820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90821       };
90822     } catch (Dali::DaliException e) {
90823       {
90824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90825       };
90826     } catch (...) {
90827       {
90828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90829       };
90830     }
90831   }
90832
90833   jresult = (void *)result;
90834   return jresult;
90835 }
90836
90837
90838 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnLandscapeView(void * jarg1) {
90839   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
90840
90841   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
90842   {
90843     try {
90844       delete arg1;
90845     } catch (std::out_of_range& e) {
90846       {
90847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90848       };
90849     } catch (std::exception& e) {
90850       {
90851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90852       };
90853     } catch (Dali::DaliException e) {
90854       {
90855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90856       };
90857     } catch (...) {
90858       {
90859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90860       };
90861     }
90862   }
90863
90864 }
90865
90866
90867 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_New(void * jarg1, void * jarg2) {
90868   void * jresult ;
90869   Dali::Toolkit::PageFactory *arg1 = 0 ;
90870   Dali::Vector2 *arg2 = 0 ;
90871   Dali::Toolkit::PageTurnLandscapeView result;
90872
90873   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
90874   if (!arg1) {
90875     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
90876     return 0;
90877   }
90878   arg2 = (Dali::Vector2 *)jarg2;
90879   if (!arg2) {
90880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
90881     return 0;
90882   }
90883   {
90884     try {
90885       result = Dali::Toolkit::PageTurnLandscapeView::New(*arg1,(Dali::Vector2 const &)*arg2);
90886     } catch (std::out_of_range& e) {
90887       {
90888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90889       };
90890     } catch (std::exception& e) {
90891       {
90892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90893       };
90894     } catch (Dali::DaliException e) {
90895       {
90896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90897       };
90898     } catch (...) {
90899       {
90900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90901       };
90902     }
90903   }
90904
90905   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
90906   return jresult;
90907 }
90908
90909
90910 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_DownCast(void * jarg1) {
90911   void * jresult ;
90912   Dali::BaseHandle arg1 ;
90913   Dali::BaseHandle *argp1 ;
90914   Dali::Toolkit::PageTurnLandscapeView result;
90915
90916   argp1 = (Dali::BaseHandle *)jarg1;
90917   if (!argp1) {
90918     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
90919     return 0;
90920   }
90921   arg1 = *argp1;
90922   {
90923     try {
90924       result = Dali::Toolkit::PageTurnLandscapeView::DownCast(arg1);
90925     } catch (std::out_of_range& e) {
90926       {
90927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90928       };
90929     } catch (std::exception& e) {
90930       {
90931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90932       };
90933     } catch (Dali::DaliException e) {
90934       {
90935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90936       };
90937     } catch (...) {
90938       {
90939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90940       };
90941     }
90942   }
90943
90944   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
90945   return jresult;
90946 }
90947
90948
90949 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_0() {
90950   void * jresult ;
90951   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
90952
90953   {
90954     try {
90955       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView();
90956     } catch (std::out_of_range& e) {
90957       {
90958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90959       };
90960     } catch (std::exception& e) {
90961       {
90962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90963       };
90964     } catch (Dali::DaliException e) {
90965       {
90966         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90967       };
90968     } catch (...) {
90969       {
90970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90971       };
90972     }
90973   }
90974
90975   jresult = (void *)result;
90976   return jresult;
90977 }
90978
90979
90980 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_1(void * jarg1) {
90981   void * jresult ;
90982   Dali::Toolkit::PageTurnPortraitView *arg1 = 0 ;
90983   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
90984
90985   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
90986   if (!arg1) {
90987     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
90988     return 0;
90989   }
90990   {
90991     try {
90992       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView((Dali::Toolkit::PageTurnPortraitView const &)*arg1);
90993     } catch (std::out_of_range& e) {
90994       {
90995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90996       };
90997     } catch (std::exception& e) {
90998       {
90999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91000       };
91001     } catch (Dali::DaliException e) {
91002       {
91003         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91004       };
91005     } catch (...) {
91006       {
91007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91008       };
91009     }
91010   }
91011
91012   jresult = (void *)result;
91013   return jresult;
91014 }
91015
91016
91017 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_Assign(void * jarg1, void * jarg2) {
91018   void * jresult ;
91019   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
91020   Dali::Toolkit::PageTurnPortraitView *arg2 = 0 ;
91021   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
91022
91023   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
91024   arg2 = (Dali::Toolkit::PageTurnPortraitView *)jarg2;
91025   if (!arg2) {
91026     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
91027     return 0;
91028   }
91029   {
91030     try {
91031       result = (Dali::Toolkit::PageTurnPortraitView *) &(arg1)->operator =((Dali::Toolkit::PageTurnPortraitView const &)*arg2);
91032     } catch (std::out_of_range& e) {
91033       {
91034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91035       };
91036     } catch (std::exception& e) {
91037       {
91038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91039       };
91040     } catch (Dali::DaliException e) {
91041       {
91042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91043       };
91044     } catch (...) {
91045       {
91046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91047       };
91048     }
91049   }
91050
91051   jresult = (void *)result;
91052   return jresult;
91053 }
91054
91055
91056 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnPortraitView(void * jarg1) {
91057   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
91058
91059   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
91060   {
91061     try {
91062       delete arg1;
91063     } catch (std::out_of_range& e) {
91064       {
91065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91066       };
91067     } catch (std::exception& e) {
91068       {
91069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91070       };
91071     } catch (Dali::DaliException e) {
91072       {
91073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91074       };
91075     } catch (...) {
91076       {
91077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91078       };
91079     }
91080   }
91081
91082 }
91083
91084
91085 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_New(void * jarg1, void * jarg2) {
91086   void * jresult ;
91087   Dali::Toolkit::PageFactory *arg1 = 0 ;
91088   Dali::Vector2 *arg2 = 0 ;
91089   Dali::Toolkit::PageTurnPortraitView result;
91090
91091   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
91092   if (!arg1) {
91093     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
91094     return 0;
91095   }
91096   arg2 = (Dali::Vector2 *)jarg2;
91097   if (!arg2) {
91098     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
91099     return 0;
91100   }
91101   {
91102     try {
91103       result = Dali::Toolkit::PageTurnPortraitView::New(*arg1,(Dali::Vector2 const &)*arg2);
91104     } catch (std::out_of_range& e) {
91105       {
91106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91107       };
91108     } catch (std::exception& e) {
91109       {
91110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91111       };
91112     } catch (Dali::DaliException e) {
91113       {
91114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91115       };
91116     } catch (...) {
91117       {
91118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91119       };
91120     }
91121   }
91122
91123   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
91124   return jresult;
91125 }
91126
91127
91128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_DownCast(void * jarg1) {
91129   void * jresult ;
91130   Dali::BaseHandle arg1 ;
91131   Dali::BaseHandle *argp1 ;
91132   Dali::Toolkit::PageTurnPortraitView result;
91133
91134   argp1 = (Dali::BaseHandle *)jarg1;
91135   if (!argp1) {
91136     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
91137     return 0;
91138   }
91139   arg1 = *argp1;
91140   {
91141     try {
91142       result = Dali::Toolkit::PageTurnPortraitView::DownCast(arg1);
91143     } catch (std::out_of_range& e) {
91144       {
91145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91146       };
91147     } catch (std::exception& e) {
91148       {
91149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91150       };
91151     } catch (Dali::DaliException e) {
91152       {
91153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91154       };
91155     } catch (...) {
91156       {
91157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91158       };
91159     }
91160   }
91161
91162   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
91163   return jresult;
91164 }
91165
91166
91167 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_STATE_VISUALS_get() {
91168   int jresult ;
91169   int result;
91170
91171   result = (int)Dali::Toolkit::ToggleButton::Property::STATE_VISUALS;
91172   jresult = (int)result;
91173   return jresult;
91174 }
91175
91176
91177 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_TOOLTIPS_get() {
91178   int jresult ;
91179   int result;
91180
91181   result = (int)Dali::Toolkit::ToggleButton::Property::TOOLTIPS;
91182   jresult = (int)result;
91183   return jresult;
91184 }
91185
91186
91187 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_CURRENT_STATE_INDEX_get() {
91188   int jresult ;
91189   int result;
91190
91191   result = (int)Dali::Toolkit::ToggleButton::Property::CURRENT_STATE_INDEX;
91192   jresult = (int)result;
91193   return jresult;
91194 }
91195
91196
91197 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton_Property() {
91198   void * jresult ;
91199   Dali::Toolkit::ToggleButton::Property *result = 0 ;
91200
91201   {
91202     try {
91203       result = (Dali::Toolkit::ToggleButton::Property *)new Dali::Toolkit::ToggleButton::Property();
91204     } catch (std::out_of_range& e) {
91205       {
91206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91207       };
91208     } catch (std::exception& e) {
91209       {
91210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91211       };
91212     } catch (Dali::DaliException e) {
91213       {
91214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91215       };
91216     } catch (...) {
91217       {
91218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91219       };
91220     }
91221   }
91222
91223   jresult = (void *)result;
91224   return jresult;
91225 }
91226
91227
91228 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton_Property(void * jarg1) {
91229   Dali::Toolkit::ToggleButton::Property *arg1 = (Dali::Toolkit::ToggleButton::Property *) 0 ;
91230
91231   arg1 = (Dali::Toolkit::ToggleButton::Property *)jarg1;
91232   {
91233     try {
91234       delete arg1;
91235     } catch (std::out_of_range& e) {
91236       {
91237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91238       };
91239     } catch (std::exception& e) {
91240       {
91241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91242       };
91243     } catch (Dali::DaliException e) {
91244       {
91245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91246       };
91247     } catch (...) {
91248       {
91249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91250       };
91251     }
91252   }
91253
91254 }
91255
91256
91257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_0() {
91258   void * jresult ;
91259   Dali::Toolkit::ToggleButton *result = 0 ;
91260
91261   {
91262     try {
91263       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton();
91264     } catch (std::out_of_range& e) {
91265       {
91266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91267       };
91268     } catch (std::exception& e) {
91269       {
91270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91271       };
91272     } catch (Dali::DaliException e) {
91273       {
91274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91275       };
91276     } catch (...) {
91277       {
91278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91279       };
91280     }
91281   }
91282
91283   jresult = (void *)result;
91284   return jresult;
91285 }
91286
91287
91288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_1(void * jarg1) {
91289   void * jresult ;
91290   Dali::Toolkit::ToggleButton *arg1 = 0 ;
91291   Dali::Toolkit::ToggleButton *result = 0 ;
91292
91293   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
91294   if (!arg1) {
91295     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
91296     return 0;
91297   }
91298   {
91299     try {
91300       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton((Dali::Toolkit::ToggleButton const &)*arg1);
91301     } catch (std::out_of_range& e) {
91302       {
91303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91304       };
91305     } catch (std::exception& e) {
91306       {
91307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91308       };
91309     } catch (Dali::DaliException e) {
91310       {
91311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91312       };
91313     } catch (...) {
91314       {
91315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91316       };
91317     }
91318   }
91319
91320   jresult = (void *)result;
91321   return jresult;
91322 }
91323
91324
91325 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_Assign(void * jarg1, void * jarg2) {
91326   void * jresult ;
91327   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
91328   Dali::Toolkit::ToggleButton *arg2 = 0 ;
91329   Dali::Toolkit::ToggleButton *result = 0 ;
91330
91331   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
91332   arg2 = (Dali::Toolkit::ToggleButton *)jarg2;
91333   if (!arg2) {
91334     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
91335     return 0;
91336   }
91337   {
91338     try {
91339       result = (Dali::Toolkit::ToggleButton *) &(arg1)->operator =((Dali::Toolkit::ToggleButton const &)*arg2);
91340     } catch (std::out_of_range& e) {
91341       {
91342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91343       };
91344     } catch (std::exception& e) {
91345       {
91346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91347       };
91348     } catch (Dali::DaliException e) {
91349       {
91350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91351       };
91352     } catch (...) {
91353       {
91354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91355       };
91356     }
91357   }
91358
91359   jresult = (void *)result;
91360   return jresult;
91361 }
91362
91363
91364 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton(void * jarg1) {
91365   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
91366
91367   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
91368   {
91369     try {
91370       delete arg1;
91371     } catch (std::out_of_range& e) {
91372       {
91373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91374       };
91375     } catch (std::exception& e) {
91376       {
91377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91378       };
91379     } catch (Dali::DaliException e) {
91380       {
91381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91382       };
91383     } catch (...) {
91384       {
91385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91386       };
91387     }
91388   }
91389
91390 }
91391
91392
91393 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_New() {
91394   void * jresult ;
91395   Dali::Toolkit::ToggleButton result;
91396
91397   {
91398     try {
91399       result = Dali::Toolkit::ToggleButton::New();
91400     } catch (std::out_of_range& e) {
91401       {
91402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91403       };
91404     } catch (std::exception& e) {
91405       {
91406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91407       };
91408     } catch (Dali::DaliException e) {
91409       {
91410         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91411       };
91412     } catch (...) {
91413       {
91414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91415       };
91416     }
91417   }
91418
91419   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
91420   return jresult;
91421 }
91422
91423
91424 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_DownCast(void * jarg1) {
91425   void * jresult ;
91426   Dali::BaseHandle arg1 ;
91427   Dali::BaseHandle *argp1 ;
91428   Dali::Toolkit::ToggleButton result;
91429
91430   argp1 = (Dali::BaseHandle *)jarg1;
91431   if (!argp1) {
91432     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
91433     return 0;
91434   }
91435   arg1 = *argp1;
91436   {
91437     try {
91438       result = Dali::Toolkit::ToggleButton::DownCast(arg1);
91439     } catch (std::out_of_range& e) {
91440       {
91441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91442       };
91443     } catch (std::exception& e) {
91444       {
91445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91446       };
91447     } catch (Dali::DaliException e) {
91448       {
91449         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91450       };
91451     } catch (...) {
91452       {
91453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91454       };
91455     }
91456   }
91457
91458   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
91459   return jresult;
91460 }
91461
91462
91463 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_0() {
91464   void * jresult ;
91465   Dali::Toolkit::Visual::Base *result = 0 ;
91466
91467   {
91468     try {
91469       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base();
91470     } catch (std::out_of_range& e) {
91471       {
91472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91473       };
91474     } catch (std::exception& e) {
91475       {
91476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91477       };
91478     } catch (Dali::DaliException e) {
91479       {
91480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91481       };
91482     } catch (...) {
91483       {
91484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91485       };
91486     }
91487   }
91488
91489   jresult = (void *)result;
91490   return jresult;
91491 }
91492
91493
91494 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualBase(void * jarg1) {
91495   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91496
91497   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91498   {
91499     try {
91500       delete arg1;
91501     } catch (std::out_of_range& e) {
91502       {
91503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91504       };
91505     } catch (std::exception& e) {
91506       {
91507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91508       };
91509     } catch (Dali::DaliException e) {
91510       {
91511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91512       };
91513     } catch (...) {
91514       {
91515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91516       };
91517     }
91518   }
91519
91520 }
91521
91522
91523 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_1(void * jarg1) {
91524   void * jresult ;
91525   Dali::Toolkit::Visual::Base *arg1 = 0 ;
91526   Dali::Toolkit::Visual::Base *result = 0 ;
91527
91528   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91529   if (!arg1) {
91530     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
91531     return 0;
91532   }
91533   {
91534     try {
91535       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base((Dali::Toolkit::Visual::Base const &)*arg1);
91536     } catch (std::out_of_range& e) {
91537       {
91538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91539       };
91540     } catch (std::exception& e) {
91541       {
91542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91543       };
91544     } catch (Dali::DaliException e) {
91545       {
91546         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91547       };
91548     } catch (...) {
91549       {
91550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91551       };
91552     }
91553   }
91554
91555   jresult = (void *)result;
91556   return jresult;
91557 }
91558
91559
91560 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualBase_Assign(void * jarg1, void * jarg2) {
91561   void * jresult ;
91562   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91563   Dali::Toolkit::Visual::Base *arg2 = 0 ;
91564   Dali::Toolkit::Visual::Base *result = 0 ;
91565
91566   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91567   arg2 = (Dali::Toolkit::Visual::Base *)jarg2;
91568   if (!arg2) {
91569     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
91570     return 0;
91571   }
91572   {
91573     try {
91574       result = (Dali::Toolkit::Visual::Base *) &(arg1)->operator =((Dali::Toolkit::Visual::Base const &)*arg2);
91575     } catch (std::out_of_range& e) {
91576       {
91577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91578       };
91579     } catch (std::exception& e) {
91580       {
91581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91582       };
91583     } catch (Dali::DaliException e) {
91584       {
91585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91586       };
91587     } catch (...) {
91588       {
91589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91590       };
91591     }
91592   }
91593
91594   jresult = (void *)result;
91595   return jresult;
91596 }
91597
91598
91599 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetName(void * jarg1, char * jarg2) {
91600   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91601   std::string *arg2 = 0 ;
91602
91603   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91604   if (!jarg2) {
91605     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91606     return ;
91607   }
91608   std::string arg2_str(jarg2);
91609   arg2 = &arg2_str;
91610   {
91611     try {
91612       (arg1)->SetName((std::string const &)*arg2);
91613     } catch (std::out_of_range& e) {
91614       {
91615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91616       };
91617     } catch (std::exception& e) {
91618       {
91619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91620       };
91621     } catch (Dali::DaliException e) {
91622       {
91623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91624       };
91625     } catch (...) {
91626       {
91627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91628       };
91629     }
91630   }
91631
91632
91633   //argout typemap for const std::string&
91634
91635 }
91636
91637
91638 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_VisualBase_GetName(void * jarg1) {
91639   char * jresult ;
91640   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91641   std::string *result = 0 ;
91642
91643   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91644   {
91645     try {
91646       result = (std::string *) &(arg1)->GetName();
91647     } catch (std::out_of_range& e) {
91648       {
91649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91650       };
91651     } catch (std::exception& e) {
91652       {
91653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91654       };
91655     } catch (Dali::DaliException e) {
91656       {
91657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91658       };
91659     } catch (...) {
91660       {
91661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91662       };
91663     }
91664   }
91665
91666   jresult = SWIG_csharp_string_callback(result->c_str());
91667   return jresult;
91668 }
91669
91670
91671 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetTransformAndSize(void * jarg1, void * jarg2, void * jarg3) {
91672   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91673   Dali::Property::Map *arg2 = 0 ;
91674   Dali::Size arg3 ;
91675   Dali::Size *argp3 ;
91676
91677   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91678   arg2 = (Dali::Property::Map *)jarg2;
91679   if (!arg2) {
91680     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
91681     return ;
91682   }
91683   argp3 = (Dali::Size *)jarg3;
91684   if (!argp3) {
91685     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
91686     return ;
91687   }
91688   arg3 = *argp3;
91689   {
91690     try {
91691       (arg1)->SetTransformAndSize((Dali::Property::Map const &)*arg2,arg3);
91692     } catch (std::out_of_range& e) {
91693       {
91694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91695       };
91696     } catch (std::exception& e) {
91697       {
91698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91699       };
91700     } catch (Dali::DaliException e) {
91701       {
91702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91703       };
91704     } catch (...) {
91705       {
91706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91707       };
91708     }
91709   }
91710
91711 }
91712
91713
91714 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetHeightForWidth(void * jarg1, float jarg2) {
91715   float jresult ;
91716   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91717   float arg2 ;
91718   float result;
91719
91720   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91721   arg2 = (float)jarg2;
91722   {
91723     try {
91724       result = (float)(arg1)->GetHeightForWidth(arg2);
91725     } catch (std::out_of_range& e) {
91726       {
91727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91728       };
91729     } catch (std::exception& e) {
91730       {
91731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91732       };
91733     } catch (Dali::DaliException e) {
91734       {
91735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91736       };
91737     } catch (...) {
91738       {
91739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91740       };
91741     }
91742   }
91743
91744   jresult = result;
91745   return jresult;
91746 }
91747
91748
91749 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetWidthForHeight(void * jarg1, float jarg2) {
91750   float jresult ;
91751   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91752   float arg2 ;
91753   float result;
91754
91755   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91756   arg2 = (float)jarg2;
91757   {
91758     try {
91759       result = (float)(arg1)->GetWidthForHeight(arg2);
91760     } catch (std::out_of_range& e) {
91761       {
91762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91763       };
91764     } catch (std::exception& e) {
91765       {
91766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91767       };
91768     } catch (Dali::DaliException e) {
91769       {
91770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91771       };
91772     } catch (...) {
91773       {
91774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91775       };
91776     }
91777   }
91778
91779   jresult = result;
91780   return jresult;
91781 }
91782
91783
91784 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_GetNaturalSize(void * jarg1, void * jarg2) {
91785   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91786   Dali::Vector2 *arg2 = 0 ;
91787
91788   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91789   arg2 = (Dali::Vector2 *)jarg2;
91790   if (!arg2) {
91791     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
91792     return ;
91793   }
91794   {
91795     try {
91796       (arg1)->GetNaturalSize(*arg2);
91797     } catch (std::out_of_range& e) {
91798       {
91799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91800       };
91801     } catch (std::exception& e) {
91802       {
91803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91804       };
91805     } catch (Dali::DaliException e) {
91806       {
91807         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91808       };
91809     } catch (...) {
91810       {
91811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91812       };
91813     }
91814   }
91815
91816 }
91817
91818
91819 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetDepthIndex(void * jarg1, int jarg2) {
91820   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91821   float arg2 ;
91822
91823   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91824   arg2 = (int)jarg2;
91825   {
91826     try {
91827       (arg1)->SetDepthIndex(arg2);
91828     } catch (std::out_of_range& e) {
91829       {
91830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91831       };
91832     } catch (std::exception& e) {
91833       {
91834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91835       };
91836     } catch (Dali::DaliException e) {
91837       {
91838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91839       };
91840     } catch (...) {
91841       {
91842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91843       };
91844     }
91845   }
91846
91847 }
91848
91849
91850 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VisualBase_GetDepthIndex(void * jarg1) {
91851   int jresult ;
91852   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91853   int result;
91854
91855   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91856   {
91857     try {
91858       result = (float)((Dali::Toolkit::Visual::Base const *)arg1)->GetDepthIndex();
91859     } catch (std::out_of_range& e) {
91860       {
91861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91862       };
91863     } catch (std::exception& e) {
91864       {
91865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91866       };
91867     } catch (Dali::DaliException e) {
91868       {
91869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91870       };
91871     } catch (...) {
91872       {
91873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91874       };
91875     }
91876   }
91877
91878   jresult = result;
91879   return jresult;
91880 }
91881
91882
91883 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_CreatePropertyMap(void * jarg1, void * jarg2) {
91884   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91885   Dali::Property::Map *arg2 = 0 ;
91886
91887   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91888   arg2 = (Dali::Property::Map *)jarg2;
91889   if (!arg2) {
91890     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
91891     return ;
91892   }
91893   {
91894     try {
91895       ((Dali::Toolkit::Visual::Base const *)arg1)->CreatePropertyMap(*arg2);
91896     } catch (std::out_of_range& e) {
91897       {
91898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91899       };
91900     } catch (std::exception& e) {
91901       {
91902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91903       };
91904     } catch (Dali::DaliException e) {
91905       {
91906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91907       };
91908     } catch (...) {
91909       {
91910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91911       };
91912     }
91913   }
91914
91915 }
91916
91917
91918 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_2(void * jarg1) {
91919   void * jresult ;
91920   Dali::Toolkit::Internal::Visual::Base *arg1 = (Dali::Toolkit::Internal::Visual::Base *) 0 ;
91921   Dali::Toolkit::Visual::Base *result = 0 ;
91922
91923   arg1 = (Dali::Toolkit::Internal::Visual::Base *)jarg1;
91924   {
91925     try {
91926       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base(arg1);
91927     } catch (std::out_of_range& e) {
91928       {
91929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91930       };
91931     } catch (std::exception& e) {
91932       {
91933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91934       };
91935     } catch (Dali::DaliException e) {
91936       {
91937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91938       };
91939     } catch (...) {
91940       {
91941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91942       };
91943     }
91944   }
91945
91946   jresult = (void *)result;
91947   return jresult;
91948 }
91949
91950
91951 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Get() {
91952   void * jresult ;
91953   Dali::Toolkit::VisualFactory result;
91954
91955   {
91956     try {
91957       result = Dali::Toolkit::VisualFactory::Get();
91958     } catch (std::out_of_range& e) {
91959       {
91960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91961       };
91962     } catch (std::exception& e) {
91963       {
91964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91965       };
91966     } catch (Dali::DaliException e) {
91967       {
91968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91969       };
91970     } catch (...) {
91971       {
91972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91973       };
91974     }
91975   }
91976
91977   jresult = new Dali::Toolkit::VisualFactory((const Dali::Toolkit::VisualFactory &)result);
91978   return jresult;
91979 }
91980
91981
91982 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_0() {
91983   void * jresult ;
91984   Dali::Toolkit::VisualFactory *result = 0 ;
91985
91986   {
91987     try {
91988       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory();
91989     } catch (std::out_of_range& e) {
91990       {
91991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91992       };
91993     } catch (std::exception& e) {
91994       {
91995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91996       };
91997     } catch (Dali::DaliException e) {
91998       {
91999         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92000       };
92001     } catch (...) {
92002       {
92003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92004       };
92005     }
92006   }
92007
92008   jresult = (void *)result;
92009   return jresult;
92010 }
92011
92012
92013 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualFactory(void * jarg1) {
92014   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
92015
92016   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
92017   {
92018     try {
92019       delete arg1;
92020     } catch (std::out_of_range& e) {
92021       {
92022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92023       };
92024     } catch (std::exception& e) {
92025       {
92026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92027       };
92028     } catch (Dali::DaliException e) {
92029       {
92030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92031       };
92032     } catch (...) {
92033       {
92034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92035       };
92036     }
92037   }
92038
92039 }
92040
92041
92042 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_1(void * jarg1) {
92043   void * jresult ;
92044   Dali::Toolkit::VisualFactory *arg1 = 0 ;
92045   Dali::Toolkit::VisualFactory *result = 0 ;
92046
92047   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
92048   if (!arg1) {
92049     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
92050     return 0;
92051   }
92052   {
92053     try {
92054       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory((Dali::Toolkit::VisualFactory const &)*arg1);
92055     } catch (std::out_of_range& e) {
92056       {
92057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92058       };
92059     } catch (std::exception& e) {
92060       {
92061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92062       };
92063     } catch (Dali::DaliException e) {
92064       {
92065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92066       };
92067     } catch (...) {
92068       {
92069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92070       };
92071     }
92072   }
92073
92074   jresult = (void *)result;
92075   return jresult;
92076 }
92077
92078
92079 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Assign(void * jarg1, void * jarg2) {
92080   void * jresult ;
92081   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
92082   Dali::Toolkit::VisualFactory *arg2 = 0 ;
92083   Dali::Toolkit::VisualFactory *result = 0 ;
92084
92085   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
92086   arg2 = (Dali::Toolkit::VisualFactory *)jarg2;
92087   if (!arg2) {
92088     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
92089     return 0;
92090   }
92091   {
92092     try {
92093       result = (Dali::Toolkit::VisualFactory *) &(arg1)->operator =((Dali::Toolkit::VisualFactory const &)*arg2);
92094     } catch (std::out_of_range& e) {
92095       {
92096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92097       };
92098     } catch (std::exception& e) {
92099       {
92100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92101       };
92102     } catch (Dali::DaliException e) {
92103       {
92104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92105       };
92106     } catch (...) {
92107       {
92108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92109       };
92110     }
92111   }
92112
92113   jresult = (void *)result;
92114   return jresult;
92115 }
92116
92117
92118 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_0(void * jarg1, void * jarg2) {
92119   void * jresult ;
92120   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
92121   Dali::Property::Map *arg2 = 0 ;
92122   Dali::Toolkit::Visual::Base result;
92123
92124   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
92125   arg2 = (Dali::Property::Map *)jarg2;
92126   if (!arg2) {
92127     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
92128     return 0;
92129   }
92130   {
92131     try {
92132       result = (arg1)->CreateVisual((Dali::Property::Map const &)*arg2);
92133     } catch (std::out_of_range& e) {
92134       {
92135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92136       };
92137     } catch (std::exception& e) {
92138       {
92139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92140       };
92141     } catch (Dali::DaliException e) {
92142       {
92143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92144       };
92145     } catch (...) {
92146       {
92147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92148       };
92149     }
92150   }
92151
92152   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
92153   return jresult;
92154 }
92155
92156
92157 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_1(void * jarg1, void * jarg2) {
92158   void * jresult ;
92159   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
92160   Dali::Image *arg2 = 0 ;
92161   Dali::Toolkit::Visual::Base result;
92162
92163   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
92164   arg2 = (Dali::Image *)jarg2;
92165   if (!arg2) {
92166     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
92167     return 0;
92168   }
92169   {
92170     try {
92171       result = (arg1)->CreateVisual((Dali::Image const &)*arg2);
92172     } catch (std::out_of_range& e) {
92173       {
92174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92175       };
92176     } catch (std::exception& e) {
92177       {
92178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92179       };
92180     } catch (Dali::DaliException e) {
92181       {
92182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92183       };
92184     } catch (...) {
92185       {
92186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92187       };
92188     }
92189   }
92190
92191   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
92192   return jresult;
92193 }
92194
92195
92196 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
92197   void * jresult ;
92198   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
92199   std::string *arg2 = 0 ;
92200   Dali::ImageDimensions arg3 ;
92201   Dali::ImageDimensions *argp3 ;
92202   Dali::Toolkit::Visual::Base result;
92203
92204   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
92205   if (!jarg2) {
92206     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92207     return 0;
92208   }
92209   std::string arg2_str(jarg2);
92210   arg2 = &arg2_str;
92211   argp3 = (Dali::ImageDimensions *)jarg3;
92212   if (!argp3) {
92213     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
92214     return 0;
92215   }
92216   arg3 = *argp3;
92217   {
92218     try {
92219       result = (arg1)->CreateVisual((std::string const &)*arg2,arg3);
92220     } catch (std::out_of_range& e) {
92221       {
92222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92223       };
92224     } catch (std::exception& e) {
92225       {
92226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92227       };
92228     } catch (Dali::DaliException e) {
92229       {
92230         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92231       };
92232     } catch (...) {
92233       {
92234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92235       };
92236     }
92237   }
92238
92239   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
92240
92241   //argout typemap for const std::string&
92242
92243   return jresult;
92244 }
92245
92246
92247 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_0() {
92248   void * jresult ;
92249   Dali::Toolkit::AsyncImageLoader *result = 0 ;
92250
92251   {
92252     try {
92253       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader();
92254     } catch (std::out_of_range& e) {
92255       {
92256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92257       };
92258     } catch (std::exception& e) {
92259       {
92260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92261       };
92262     } catch (Dali::DaliException e) {
92263       {
92264         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92265       };
92266     } catch (...) {
92267       {
92268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92269       };
92270     }
92271   }
92272
92273   jresult = (void *)result;
92274   return jresult;
92275 }
92276
92277
92278 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AsyncImageLoader(void * jarg1) {
92279   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92280
92281   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92282   {
92283     try {
92284       delete arg1;
92285     } catch (std::out_of_range& e) {
92286       {
92287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92288       };
92289     } catch (std::exception& e) {
92290       {
92291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92292       };
92293     } catch (Dali::DaliException e) {
92294       {
92295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92296       };
92297     } catch (...) {
92298       {
92299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92300       };
92301     }
92302   }
92303
92304 }
92305
92306
92307 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_1(void * jarg1) {
92308   void * jresult ;
92309   Dali::Toolkit::AsyncImageLoader *arg1 = 0 ;
92310   Dali::Toolkit::AsyncImageLoader *result = 0 ;
92311
92312   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92313   if (!arg1) {
92314     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
92315     return 0;
92316   }
92317   {
92318     try {
92319       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader((Dali::Toolkit::AsyncImageLoader const &)*arg1);
92320     } catch (std::out_of_range& e) {
92321       {
92322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92323       };
92324     } catch (std::exception& e) {
92325       {
92326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92327       };
92328     } catch (Dali::DaliException e) {
92329       {
92330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92331       };
92332     } catch (...) {
92333       {
92334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92335       };
92336     }
92337   }
92338
92339   jresult = (void *)result;
92340   return jresult;
92341 }
92342
92343
92344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Assign(void * jarg1, void * jarg2) {
92345   void * jresult ;
92346   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92347   Dali::Toolkit::AsyncImageLoader *arg2 = 0 ;
92348   Dali::Toolkit::AsyncImageLoader *result = 0 ;
92349
92350   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92351   arg2 = (Dali::Toolkit::AsyncImageLoader *)jarg2;
92352   if (!arg2) {
92353     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
92354     return 0;
92355   }
92356   {
92357     try {
92358       result = (Dali::Toolkit::AsyncImageLoader *) &(arg1)->operator =((Dali::Toolkit::AsyncImageLoader const &)*arg2);
92359     } catch (std::out_of_range& e) {
92360       {
92361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92362       };
92363     } catch (std::exception& e) {
92364       {
92365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92366       };
92367     } catch (Dali::DaliException e) {
92368       {
92369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92370       };
92371     } catch (...) {
92372       {
92373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92374       };
92375     }
92376   }
92377
92378   jresult = (void *)result;
92379   return jresult;
92380 }
92381
92382
92383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_New() {
92384   void * jresult ;
92385   Dali::Toolkit::AsyncImageLoader result;
92386
92387   {
92388     try {
92389       result = Dali::Toolkit::AsyncImageLoader::New();
92390     } catch (std::out_of_range& e) {
92391       {
92392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92393       };
92394     } catch (std::exception& e) {
92395       {
92396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92397       };
92398     } catch (Dali::DaliException e) {
92399       {
92400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92401       };
92402     } catch (...) {
92403       {
92404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92405       };
92406     }
92407   }
92408
92409   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
92410   return jresult;
92411 }
92412
92413
92414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_DownCast(void * jarg1) {
92415   void * jresult ;
92416   Dali::BaseHandle arg1 ;
92417   Dali::BaseHandle *argp1 ;
92418   Dali::Toolkit::AsyncImageLoader result;
92419
92420   argp1 = (Dali::BaseHandle *)jarg1;
92421   if (!argp1) {
92422     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
92423     return 0;
92424   }
92425   arg1 = *argp1;
92426   {
92427     try {
92428       result = Dali::Toolkit::AsyncImageLoader::DownCast(arg1);
92429     } catch (std::out_of_range& e) {
92430       {
92431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92432       };
92433     } catch (std::exception& e) {
92434       {
92435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92436       };
92437     } catch (Dali::DaliException e) {
92438       {
92439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92440       };
92441     } catch (...) {
92442       {
92443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92444       };
92445     }
92446   }
92447
92448   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
92449   return jresult;
92450 }
92451
92452
92453 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_0(void * jarg1, char * jarg2) {
92454   unsigned int jresult ;
92455   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92456   std::string *arg2 = 0 ;
92457   uint32_t result;
92458
92459   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92460   if (!jarg2) {
92461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92462     return 0;
92463   }
92464   std::string arg2_str(jarg2);
92465   arg2 = &arg2_str;
92466   {
92467     try {
92468       result = (arg1)->Load((std::string const &)*arg2);
92469     } catch (std::out_of_range& e) {
92470       {
92471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92472       };
92473     } catch (std::exception& e) {
92474       {
92475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92476       };
92477     } catch (Dali::DaliException e) {
92478       {
92479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92480       };
92481     } catch (...) {
92482       {
92483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92484       };
92485     }
92486   }
92487
92488   jresult = result;
92489
92490   //argout typemap for const std::string&
92491
92492   return jresult;
92493 }
92494
92495
92496 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
92497   unsigned int jresult ;
92498   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92499   std::string *arg2 = 0 ;
92500   Dali::ImageDimensions arg3 ;
92501   Dali::ImageDimensions *argp3 ;
92502   uint32_t result;
92503
92504   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92505   if (!jarg2) {
92506     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92507     return 0;
92508   }
92509   std::string arg2_str(jarg2);
92510   arg2 = &arg2_str;
92511   argp3 = (Dali::ImageDimensions *)jarg3;
92512   if (!argp3) {
92513     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
92514     return 0;
92515   }
92516   arg3 = *argp3;
92517   {
92518     try {
92519       result = (arg1)->Load((std::string const &)*arg2,arg3);
92520     } catch (std::out_of_range& e) {
92521       {
92522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92523       };
92524     } catch (std::exception& e) {
92525       {
92526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92527       };
92528     } catch (Dali::DaliException e) {
92529       {
92530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92531       };
92532     } catch (...) {
92533       {
92534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92535       };
92536     }
92537   }
92538
92539   jresult = result;
92540
92541   //argout typemap for const std::string&
92542
92543   return jresult;
92544 }
92545
92546
92547 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_2(void * jarg1, char * jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
92548   unsigned int jresult ;
92549   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92550   std::string *arg2 = 0 ;
92551   Dali::ImageDimensions arg3 ;
92552   Dali::FittingMode::Type arg4 ;
92553   Dali::SamplingMode::Type arg5 ;
92554   bool arg6 ;
92555   Dali::ImageDimensions *argp3 ;
92556   uint32_t result;
92557
92558   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92559   if (!jarg2) {
92560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92561     return 0;
92562   }
92563   std::string arg2_str(jarg2);
92564   arg2 = &arg2_str;
92565   argp3 = (Dali::ImageDimensions *)jarg3;
92566   if (!argp3) {
92567     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
92568     return 0;
92569   }
92570   arg3 = *argp3;
92571   arg4 = (Dali::FittingMode::Type)jarg4;
92572   arg5 = (Dali::SamplingMode::Type)jarg5;
92573   arg6 = jarg6 ? true : false;
92574   {
92575     try {
92576       result = (arg1)->Load((std::string const &)*arg2,arg3,arg4,arg5,arg6);
92577     } catch (std::out_of_range& e) {
92578       {
92579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92580       };
92581     } catch (std::exception& e) {
92582       {
92583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92584       };
92585     } catch (Dali::DaliException e) {
92586       {
92587         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92588       };
92589     } catch (...) {
92590       {
92591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92592       };
92593     }
92594   }
92595
92596   jresult = result;
92597
92598   //argout typemap for const std::string&
92599
92600   return jresult;
92601 }
92602
92603
92604 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Cancel(void * jarg1, unsigned int jarg2) {
92605   unsigned int jresult ;
92606   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92607   uint32_t arg2 ;
92608   bool result;
92609
92610   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92611   arg2 = (uint32_t)jarg2;
92612   {
92613     try {
92614       result = (bool)(arg1)->Cancel(arg2);
92615     } catch (std::out_of_range& e) {
92616       {
92617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92618       };
92619     } catch (std::exception& e) {
92620       {
92621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92622       };
92623     } catch (Dali::DaliException e) {
92624       {
92625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92626       };
92627     } catch (...) {
92628       {
92629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92630       };
92631     }
92632   }
92633
92634   jresult = result;
92635   return jresult;
92636 }
92637
92638
92639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AsyncImageLoader_CancelAll(void * jarg1) {
92640   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92641
92642   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92643   {
92644     try {
92645       (arg1)->CancelAll();
92646     } catch (std::out_of_range& e) {
92647       {
92648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92649       };
92650     } catch (std::exception& e) {
92651       {
92652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92653       };
92654     } catch (Dali::DaliException e) {
92655       {
92656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92657       };
92658     } catch (...) {
92659       {
92660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92661       };
92662     }
92663   }
92664
92665 }
92666
92667
92668 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_ImageLoadedSignal(void * jarg1) {
92669   void * jresult ;
92670   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92671   Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *result = 0 ;
92672
92673   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92674   {
92675     try {
92676       result = (Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *) &(arg1)->ImageLoadedSignal();
92677     } catch (std::out_of_range& e) {
92678       {
92679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92680       };
92681     } catch (std::exception& e) {
92682       {
92683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92684       };
92685     } catch (Dali::DaliException e) {
92686       {
92687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92688       };
92689     } catch (...) {
92690       {
92691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92692       };
92693     }
92694   }
92695
92696   jresult = (void *)result;
92697   return jresult;
92698 }
92699
92700
92701 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_2(void * jarg1) {
92702   void * jresult ;
92703   Dali::Toolkit::Internal::AsyncImageLoader *arg1 = (Dali::Toolkit::Internal::AsyncImageLoader *) 0 ;
92704   Dali::Toolkit::AsyncImageLoader *result = 0 ;
92705
92706   arg1 = (Dali::Toolkit::Internal::AsyncImageLoader *)jarg1;
92707   {
92708     try {
92709       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader(arg1);
92710     } catch (std::out_of_range& e) {
92711       {
92712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92713       };
92714     } catch (std::exception& e) {
92715       {
92716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92717       };
92718     } catch (Dali::DaliException e) {
92719       {
92720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92721       };
92722     } catch (...) {
92723       {
92724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92725       };
92726     }
92727   }
92728
92729   jresult = (void *)result;
92730   return jresult;
92731 }
92732
92733
92734 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_0(char * jarg1) {
92735   void * jresult ;
92736   std::string *arg1 = 0 ;
92737   Dali::PixelData result;
92738
92739   if (!jarg1) {
92740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92741     return 0;
92742   }
92743   std::string arg1_str(jarg1);
92744   arg1 = &arg1_str;
92745   {
92746     try {
92747       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1);
92748     } catch (std::out_of_range& e) {
92749       {
92750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92751       };
92752     } catch (std::exception& e) {
92753       {
92754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92755       };
92756     } catch (Dali::DaliException e) {
92757       {
92758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92759       };
92760     } catch (...) {
92761       {
92762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92763       };
92764     }
92765   }
92766
92767   jresult = new Dali::PixelData((const Dali::PixelData &)result);
92768
92769   //argout typemap for const std::string&
92770
92771   return jresult;
92772 }
92773
92774
92775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_1(char * jarg1, void * jarg2) {
92776   void * jresult ;
92777   std::string *arg1 = 0 ;
92778   Dali::ImageDimensions arg2 ;
92779   Dali::ImageDimensions *argp2 ;
92780   Dali::PixelData result;
92781
92782   if (!jarg1) {
92783     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92784     return 0;
92785   }
92786   std::string arg1_str(jarg1);
92787   arg1 = &arg1_str;
92788   argp2 = (Dali::ImageDimensions *)jarg2;
92789   if (!argp2) {
92790     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
92791     return 0;
92792   }
92793   arg2 = *argp2;
92794   {
92795     try {
92796       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2);
92797     } catch (std::out_of_range& e) {
92798       {
92799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92800       };
92801     } catch (std::exception& e) {
92802       {
92803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92804       };
92805     } catch (Dali::DaliException e) {
92806       {
92807         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92808       };
92809     } catch (...) {
92810       {
92811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92812       };
92813     }
92814   }
92815
92816   jresult = new Dali::PixelData((const Dali::PixelData &)result);
92817
92818   //argout typemap for const std::string&
92819
92820   return jresult;
92821 }
92822
92823
92824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
92825   void * jresult ;
92826   std::string *arg1 = 0 ;
92827   Dali::ImageDimensions arg2 ;
92828   Dali::FittingMode::Type arg3 ;
92829   Dali::SamplingMode::Type arg4 ;
92830   bool arg5 ;
92831   Dali::ImageDimensions *argp2 ;
92832   Dali::PixelData result;
92833
92834   if (!jarg1) {
92835     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92836     return 0;
92837   }
92838   std::string arg1_str(jarg1);
92839   arg1 = &arg1_str;
92840   argp2 = (Dali::ImageDimensions *)jarg2;
92841   if (!argp2) {
92842     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
92843     return 0;
92844   }
92845   arg2 = *argp2;
92846   arg3 = (Dali::FittingMode::Type)jarg3;
92847   arg4 = (Dali::SamplingMode::Type)jarg4;
92848   arg5 = jarg5 ? true : false;
92849   {
92850     try {
92851       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2,arg3,arg4,arg5);
92852     } catch (std::out_of_range& e) {
92853       {
92854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92855       };
92856     } catch (std::exception& e) {
92857       {
92858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92859       };
92860     } catch (Dali::DaliException e) {
92861       {
92862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92863       };
92864     } catch (...) {
92865       {
92866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92867       };
92868     }
92869   }
92870
92871   jresult = new Dali::PixelData((const Dali::PixelData &)result);
92872
92873   //argout typemap for const std::string&
92874
92875   return jresult;
92876 }
92877
92878
92879 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomAlgorithmInterface(void * jarg1) {
92880   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
92881
92882   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
92883   {
92884     try {
92885       delete arg1;
92886     } catch (std::out_of_range& e) {
92887       {
92888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92889       };
92890     } catch (std::exception& e) {
92891       {
92892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92893       };
92894     } catch (Dali::DaliException e) {
92895       {
92896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92897       };
92898     } catch (...) {
92899       {
92900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92901       };
92902     }
92903   }
92904
92905 }
92906
92907
92908 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_GetNextFocusableActor(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
92909   void * jresult ;
92910   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
92911   Dali::Actor arg2 ;
92912   Dali::Actor arg3 ;
92913   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
92914   Dali::Actor *argp2 ;
92915   Dali::Actor *argp3 ;
92916   Dali::Actor result;
92917
92918   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
92919   argp2 = (Dali::Actor *)jarg2;
92920   if (!argp2) {
92921     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
92922     return 0;
92923   }
92924   arg2 = *argp2;
92925   argp3 = (Dali::Actor *)jarg3;
92926   if (!argp3) {
92927     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
92928     return 0;
92929   }
92930   arg3 = *argp3;
92931   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
92932   {
92933     try {
92934       result = (arg1)->GetNextFocusableActor(arg2,arg3,arg4);
92935     } catch (std::out_of_range& e) {
92936       {
92937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92938       };
92939     } catch (std::exception& e) {
92940       {
92941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92942       };
92943     } catch (Dali::DaliException e) {
92944       {
92945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92946       };
92947     } catch (...) {
92948       {
92949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92950       };
92951     }
92952   }
92953
92954   jresult = new Dali::Actor((const Dali::Actor &)result);
92955   return jresult;
92956 }
92957
92958
92959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomAlgorithmInterface() {
92960   void * jresult ;
92961   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *result = 0 ;
92962
92963   {
92964     try {
92965       result = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)new SwigDirector_CustomAlgorithmInterface();
92966     } catch (std::out_of_range& e) {
92967       {
92968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92969       };
92970     } catch (std::exception& e) {
92971       {
92972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92973       };
92974     } catch (Dali::DaliException e) {
92975       {
92976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92977       };
92978     } catch (...) {
92979       {
92980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92981       };
92982     }
92983   }
92984
92985   jresult = (void *)result;
92986   return jresult;
92987 }
92988
92989
92990 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_director_connect(void *objarg, SwigDirector_CustomAlgorithmInterface::SWIG_Callback0_t callback0) {
92991   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *obj = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)objarg;
92992   SwigDirector_CustomAlgorithmInterface *director = dynamic_cast<SwigDirector_CustomAlgorithmInterface *>(obj);
92993   if (director) {
92994     director->swig_connect_director(callback0);
92995   }
92996 }
92997
92998
92999 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetCustomAlgorithm(void * jarg1, void * jarg2) {
93000   KeyboardFocusManager arg1 ;
93001   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg2 = 0 ;
93002   KeyboardFocusManager *argp1 ;
93003
93004   argp1 = (KeyboardFocusManager *)jarg1;
93005   if (!argp1) {
93006     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
93007     return ;
93008   }
93009   arg1 = *argp1;
93010   arg2 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg2;
93011   if (!arg2) {
93012     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface & type is null", 0);
93013     return ;
93014   }
93015   {
93016     try {
93017       Dali::Toolkit::DevelKeyboardFocusManager::SetCustomAlgorithm(arg1,*arg2);
93018     } catch (std::out_of_range& e) {
93019       {
93020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93021       };
93022     } catch (std::exception& e) {
93023       {
93024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93025       };
93026     } catch (Dali::DaliException e) {
93027       {
93028         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93029       };
93030     } catch (...) {
93031       {
93032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93033       };
93034     }
93035   }
93036
93037 }
93038
93039
93040 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Clear(void * jarg1) {
93041   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93042
93043   arg1 = (std::vector< unsigned int > *)jarg1;
93044   {
93045     try {
93046       (arg1)->clear();
93047     } catch (std::out_of_range& e) {
93048       {
93049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93050       };
93051     } catch (std::exception& e) {
93052       {
93053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93054       };
93055     } catch (Dali::DaliException e) {
93056       {
93057         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93058       };
93059     } catch (...) {
93060       {
93061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93062       };
93063     }
93064   }
93065
93066 }
93067
93068
93069 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Add(void * jarg1, unsigned int jarg2) {
93070   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93071   unsigned int *arg2 = 0 ;
93072   unsigned int temp2 ;
93073
93074   arg1 = (std::vector< unsigned int > *)jarg1;
93075   temp2 = (unsigned int)jarg2;
93076   arg2 = &temp2;
93077   {
93078     try {
93079       (arg1)->push_back((unsigned int const &)*arg2);
93080     } catch (std::out_of_range& e) {
93081       {
93082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93083       };
93084     } catch (std::exception& e) {
93085       {
93086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93087       };
93088     } catch (Dali::DaliException e) {
93089       {
93090         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93091       };
93092     } catch (...) {
93093       {
93094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93095       };
93096     }
93097   }
93098
93099 }
93100
93101
93102 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_size(void * jarg1) {
93103   unsigned long jresult ;
93104   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93105   std::vector< unsigned int >::size_type result;
93106
93107   arg1 = (std::vector< unsigned int > *)jarg1;
93108   {
93109     try {
93110       result = ((std::vector< unsigned int > const *)arg1)->size();
93111     } catch (std::out_of_range& e) {
93112       {
93113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93114       };
93115     } catch (std::exception& e) {
93116       {
93117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93118       };
93119     } catch (Dali::DaliException e) {
93120       {
93121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93122       };
93123     } catch (...) {
93124       {
93125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93126       };
93127     }
93128   }
93129
93130   jresult = (unsigned long)result;
93131   return jresult;
93132 }
93133
93134
93135 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_capacity(void * jarg1) {
93136   unsigned long jresult ;
93137   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93138   std::vector< unsigned int >::size_type result;
93139
93140   arg1 = (std::vector< unsigned int > *)jarg1;
93141   {
93142     try {
93143       result = ((std::vector< unsigned int > const *)arg1)->capacity();
93144     } catch (std::out_of_range& e) {
93145       {
93146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93147       };
93148     } catch (std::exception& e) {
93149       {
93150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93151       };
93152     } catch (Dali::DaliException e) {
93153       {
93154         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93155       };
93156     } catch (...) {
93157       {
93158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93159       };
93160     }
93161   }
93162
93163   jresult = (unsigned long)result;
93164   return jresult;
93165 }
93166
93167
93168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_reserve(void * jarg1, unsigned long jarg2) {
93169   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93170   std::vector< unsigned int >::size_type arg2 ;
93171
93172   arg1 = (std::vector< unsigned int > *)jarg1;
93173   arg2 = (std::vector< unsigned int >::size_type)jarg2;
93174   {
93175     try {
93176       (arg1)->reserve(arg2);
93177     } catch (std::out_of_range& e) {
93178       {
93179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93180       };
93181     } catch (std::exception& e) {
93182       {
93183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93184       };
93185     } catch (Dali::DaliException e) {
93186       {
93187         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93188       };
93189     } catch (...) {
93190       {
93191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93192       };
93193     }
93194   }
93195
93196 }
93197
93198
93199 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_0() {
93200   void * jresult ;
93201   std::vector< unsigned int > *result = 0 ;
93202
93203   {
93204     try {
93205       result = (std::vector< unsigned int > *)new std::vector< unsigned int >();
93206     } catch (std::out_of_range& e) {
93207       {
93208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93209       };
93210     } catch (std::exception& e) {
93211       {
93212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93213       };
93214     } catch (Dali::DaliException e) {
93215       {
93216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93217       };
93218     } catch (...) {
93219       {
93220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93221       };
93222     }
93223   }
93224
93225   jresult = (void *)result;
93226   return jresult;
93227 }
93228
93229
93230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_1(void * jarg1) {
93231   void * jresult ;
93232   std::vector< unsigned int > *arg1 = 0 ;
93233   std::vector< unsigned int > *result = 0 ;
93234
93235   arg1 = (std::vector< unsigned int > *)jarg1;
93236   if (!arg1) {
93237     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
93238     return 0;
93239   }
93240   {
93241     try {
93242       result = (std::vector< unsigned int > *)new std::vector< unsigned int >((std::vector< unsigned int > const &)*arg1);
93243     } catch (std::out_of_range& e) {
93244       {
93245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93246       };
93247     } catch (std::exception& e) {
93248       {
93249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93250       };
93251     } catch (Dali::DaliException e) {
93252       {
93253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93254       };
93255     } catch (...) {
93256       {
93257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93258       };
93259     }
93260   }
93261
93262   jresult = (void *)result;
93263   return jresult;
93264 }
93265
93266
93267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_2(int jarg1) {
93268   void * jresult ;
93269   int arg1 ;
93270   std::vector< unsigned int > *result = 0 ;
93271
93272   arg1 = (int)jarg1;
93273   {
93274     try {
93275       try {
93276         result = (std::vector< unsigned int > *)new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(arg1);
93277       }
93278       catch(std::out_of_range &_e) {
93279         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93280         return 0;
93281       }
93282
93283     } catch (std::out_of_range& e) {
93284       {
93285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93286       };
93287     } catch (std::exception& e) {
93288       {
93289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93290       };
93291     } catch (Dali::DaliException e) {
93292       {
93293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93294       };
93295     } catch (...) {
93296       {
93297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93298       };
93299     }
93300   }
93301
93302   jresult = (void *)result;
93303   return jresult;
93304 }
93305
93306
93307 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitemcopy(void * jarg1, int jarg2) {
93308   unsigned int jresult ;
93309   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93310   int arg2 ;
93311   unsigned int result;
93312
93313   arg1 = (std::vector< unsigned int > *)jarg1;
93314   arg2 = (int)jarg2;
93315   {
93316     try {
93317       try {
93318         result = (unsigned int)std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(arg1,arg2);
93319       }
93320       catch(std::out_of_range &_e) {
93321         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93322         return 0;
93323       }
93324
93325     } catch (std::out_of_range& e) {
93326       {
93327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93328       };
93329     } catch (std::exception& e) {
93330       {
93331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93332       };
93333     } catch (Dali::DaliException e) {
93334       {
93335         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93336       };
93337     } catch (...) {
93338       {
93339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93340       };
93341     }
93342   }
93343
93344   jresult = result;
93345   return jresult;
93346 }
93347
93348
93349 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitem(void * jarg1, int jarg2) {
93350   unsigned int jresult ;
93351   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93352   int arg2 ;
93353   unsigned int *result = 0 ;
93354
93355   arg1 = (std::vector< unsigned int > *)jarg1;
93356   arg2 = (int)jarg2;
93357   {
93358     try {
93359       try {
93360         result = (unsigned int *) &std_vector_Sl_unsigned_SS_int_Sg__getitem(arg1,arg2);
93361       }
93362       catch(std::out_of_range &_e) {
93363         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93364         return 0;
93365       }
93366
93367     } catch (std::out_of_range& e) {
93368       {
93369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93370       };
93371     } catch (std::exception& e) {
93372       {
93373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93374       };
93375     } catch (Dali::DaliException e) {
93376       {
93377         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93378       };
93379     } catch (...) {
93380       {
93381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93382       };
93383     }
93384   }
93385
93386   jresult = *result;
93387   return jresult;
93388 }
93389
93390
93391 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_setitem(void * jarg1, int jarg2, unsigned int jarg3) {
93392   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93393   int arg2 ;
93394   unsigned int *arg3 = 0 ;
93395   unsigned int temp3 ;
93396
93397   arg1 = (std::vector< unsigned int > *)jarg1;
93398   arg2 = (int)jarg2;
93399   temp3 = (unsigned int)jarg3;
93400   arg3 = &temp3;
93401   {
93402     try {
93403       try {
93404         std_vector_Sl_unsigned_SS_int_Sg__setitem(arg1,arg2,(unsigned int const &)*arg3);
93405       }
93406       catch(std::out_of_range &_e) {
93407         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93408         return ;
93409       }
93410
93411     } catch (std::out_of_range& e) {
93412       {
93413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93414       };
93415     } catch (std::exception& e) {
93416       {
93417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93418       };
93419     } catch (Dali::DaliException e) {
93420       {
93421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93422       };
93423     } catch (...) {
93424       {
93425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93426       };
93427     }
93428   }
93429
93430 }
93431
93432
93433 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_AddRange(void * jarg1, void * jarg2) {
93434   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93435   std::vector< unsigned int > *arg2 = 0 ;
93436
93437   arg1 = (std::vector< unsigned int > *)jarg1;
93438   arg2 = (std::vector< unsigned int > *)jarg2;
93439   if (!arg2) {
93440     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
93441     return ;
93442   }
93443   {
93444     try {
93445       std_vector_Sl_unsigned_SS_int_Sg__AddRange(arg1,(std::vector< unsigned int > const &)*arg2);
93446     } catch (std::out_of_range& e) {
93447       {
93448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93449       };
93450     } catch (std::exception& e) {
93451       {
93452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93453       };
93454     } catch (Dali::DaliException e) {
93455       {
93456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93457       };
93458     } catch (...) {
93459       {
93460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93461       };
93462     }
93463   }
93464
93465 }
93466
93467
93468 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
93469   void * jresult ;
93470   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93471   int arg2 ;
93472   int arg3 ;
93473   std::vector< unsigned int > *result = 0 ;
93474
93475   arg1 = (std::vector< unsigned int > *)jarg1;
93476   arg2 = (int)jarg2;
93477   arg3 = (int)jarg3;
93478   {
93479     try {
93480       try {
93481         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__GetRange(arg1,arg2,arg3);
93482       }
93483       catch(std::out_of_range &_e) {
93484         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93485         return 0;
93486       }
93487       catch(std::invalid_argument &_e) {
93488         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
93489         return 0;
93490       }
93491
93492     } catch (std::out_of_range& e) {
93493       {
93494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93495       };
93496     } catch (std::exception& e) {
93497       {
93498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93499       };
93500     } catch (Dali::DaliException e) {
93501       {
93502         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93503       };
93504     } catch (...) {
93505       {
93506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93507       };
93508     }
93509   }
93510
93511   jresult = (void *)result;
93512   return jresult;
93513 }
93514
93515
93516 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Insert(void * jarg1, int jarg2, unsigned int jarg3) {
93517   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93518   int arg2 ;
93519   unsigned int *arg3 = 0 ;
93520   unsigned int temp3 ;
93521
93522   arg1 = (std::vector< unsigned int > *)jarg1;
93523   arg2 = (int)jarg2;
93524   temp3 = (unsigned int)jarg3;
93525   arg3 = &temp3;
93526   {
93527     try {
93528       try {
93529         std_vector_Sl_unsigned_SS_int_Sg__Insert(arg1,arg2,(unsigned int const &)*arg3);
93530       }
93531       catch(std::out_of_range &_e) {
93532         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93533         return ;
93534       }
93535
93536     } catch (std::out_of_range& e) {
93537       {
93538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93539       };
93540     } catch (std::exception& e) {
93541       {
93542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93543       };
93544     } catch (Dali::DaliException e) {
93545       {
93546         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93547       };
93548     } catch (...) {
93549       {
93550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93551       };
93552     }
93553   }
93554
93555 }
93556
93557
93558 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
93559   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93560   int arg2 ;
93561   std::vector< unsigned int > *arg3 = 0 ;
93562
93563   arg1 = (std::vector< unsigned int > *)jarg1;
93564   arg2 = (int)jarg2;
93565   arg3 = (std::vector< unsigned int > *)jarg3;
93566   if (!arg3) {
93567     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
93568     return ;
93569   }
93570   {
93571     try {
93572       try {
93573         std_vector_Sl_unsigned_SS_int_Sg__InsertRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
93574       }
93575       catch(std::out_of_range &_e) {
93576         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93577         return ;
93578       }
93579
93580     } catch (std::out_of_range& e) {
93581       {
93582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93583       };
93584     } catch (std::exception& e) {
93585       {
93586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93587       };
93588     } catch (Dali::DaliException e) {
93589       {
93590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93591       };
93592     } catch (...) {
93593       {
93594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93595       };
93596     }
93597   }
93598
93599 }
93600
93601
93602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveAt(void * jarg1, int jarg2) {
93603   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93604   int arg2 ;
93605
93606   arg1 = (std::vector< unsigned int > *)jarg1;
93607   arg2 = (int)jarg2;
93608   {
93609     try {
93610       try {
93611         std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(arg1,arg2);
93612       }
93613       catch(std::out_of_range &_e) {
93614         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93615         return ;
93616       }
93617
93618     } catch (std::out_of_range& e) {
93619       {
93620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93621       };
93622     } catch (std::exception& e) {
93623       {
93624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93625       };
93626     } catch (Dali::DaliException e) {
93627       {
93628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93629       };
93630     } catch (...) {
93631       {
93632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93633       };
93634     }
93635   }
93636
93637 }
93638
93639
93640 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
93641   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93642   int arg2 ;
93643   int arg3 ;
93644
93645   arg1 = (std::vector< unsigned int > *)jarg1;
93646   arg2 = (int)jarg2;
93647   arg3 = (int)jarg3;
93648   {
93649     try {
93650       try {
93651         std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(arg1,arg2,arg3);
93652       }
93653       catch(std::out_of_range &_e) {
93654         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93655         return ;
93656       }
93657       catch(std::invalid_argument &_e) {
93658         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
93659         return ;
93660       }
93661
93662     } catch (std::out_of_range& e) {
93663       {
93664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93665       };
93666     } catch (std::exception& e) {
93667       {
93668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93669       };
93670     } catch (Dali::DaliException e) {
93671       {
93672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93673       };
93674     } catch (...) {
93675       {
93676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93677       };
93678     }
93679   }
93680
93681 }
93682
93683
93684 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_Repeat(unsigned int jarg1, int jarg2) {
93685   void * jresult ;
93686   unsigned int *arg1 = 0 ;
93687   int arg2 ;
93688   unsigned int temp1 ;
93689   std::vector< unsigned int > *result = 0 ;
93690
93691   temp1 = (unsigned int)jarg1;
93692   arg1 = &temp1;
93693   arg2 = (int)jarg2;
93694   {
93695     try {
93696       try {
93697         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__Repeat((unsigned int const &)*arg1,arg2);
93698       }
93699       catch(std::out_of_range &_e) {
93700         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93701         return 0;
93702       }
93703
93704     } catch (std::out_of_range& e) {
93705       {
93706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93707       };
93708     } catch (std::exception& e) {
93709       {
93710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93711       };
93712     } catch (Dali::DaliException e) {
93713       {
93714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93715       };
93716     } catch (...) {
93717       {
93718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93719       };
93720     }
93721   }
93722
93723   jresult = (void *)result;
93724   return jresult;
93725 }
93726
93727
93728 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_0(void * jarg1) {
93729   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93730
93731   arg1 = (std::vector< unsigned int > *)jarg1;
93732   {
93733     try {
93734       std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(arg1);
93735     } catch (std::out_of_range& e) {
93736       {
93737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93738       };
93739     } catch (std::exception& e) {
93740       {
93741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93742       };
93743     } catch (Dali::DaliException e) {
93744       {
93745         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93746       };
93747     } catch (...) {
93748       {
93749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93750       };
93751     }
93752   }
93753
93754 }
93755
93756
93757 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
93758   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93759   int arg2 ;
93760   int arg3 ;
93761
93762   arg1 = (std::vector< unsigned int > *)jarg1;
93763   arg2 = (int)jarg2;
93764   arg3 = (int)jarg3;
93765   {
93766     try {
93767       try {
93768         std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
93769       }
93770       catch(std::out_of_range &_e) {
93771         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93772         return ;
93773       }
93774       catch(std::invalid_argument &_e) {
93775         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
93776         return ;
93777       }
93778
93779     } catch (std::out_of_range& e) {
93780       {
93781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93782       };
93783     } catch (std::exception& e) {
93784       {
93785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93786       };
93787     } catch (Dali::DaliException e) {
93788       {
93789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93790       };
93791     } catch (...) {
93792       {
93793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93794       };
93795     }
93796   }
93797
93798 }
93799
93800
93801 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
93802   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93803   int arg2 ;
93804   std::vector< unsigned int > *arg3 = 0 ;
93805
93806   arg1 = (std::vector< unsigned int > *)jarg1;
93807   arg2 = (int)jarg2;
93808   arg3 = (std::vector< unsigned int > *)jarg3;
93809   if (!arg3) {
93810     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
93811     return ;
93812   }
93813   {
93814     try {
93815       try {
93816         std_vector_Sl_unsigned_SS_int_Sg__SetRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
93817       }
93818       catch(std::out_of_range &_e) {
93819         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93820         return ;
93821       }
93822
93823     } catch (std::out_of_range& e) {
93824       {
93825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93826       };
93827     } catch (std::exception& e) {
93828       {
93829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93830       };
93831     } catch (Dali::DaliException e) {
93832       {
93833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93834       };
93835     } catch (...) {
93836       {
93837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93838       };
93839     }
93840   }
93841
93842 }
93843
93844
93845 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Contains(void * jarg1, unsigned int jarg2) {
93846   unsigned int jresult ;
93847   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93848   unsigned int *arg2 = 0 ;
93849   unsigned int temp2 ;
93850   bool result;
93851
93852   arg1 = (std::vector< unsigned int > *)jarg1;
93853   temp2 = (unsigned int)jarg2;
93854   arg2 = &temp2;
93855   {
93856     try {
93857       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Contains(arg1,(unsigned int const &)*arg2);
93858     } catch (std::out_of_range& e) {
93859       {
93860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93861       };
93862     } catch (std::exception& e) {
93863       {
93864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93865       };
93866     } catch (Dali::DaliException e) {
93867       {
93868         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93869       };
93870     } catch (...) {
93871       {
93872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93873       };
93874     }
93875   }
93876
93877   jresult = result;
93878   return jresult;
93879 }
93880
93881
93882 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_IndexOf(void * jarg1, unsigned int jarg2) {
93883   int jresult ;
93884   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93885   unsigned int *arg2 = 0 ;
93886   unsigned int temp2 ;
93887   int result;
93888
93889   arg1 = (std::vector< unsigned int > *)jarg1;
93890   temp2 = (unsigned int)jarg2;
93891   arg2 = &temp2;
93892   {
93893     try {
93894       result = (int)std_vector_Sl_unsigned_SS_int_Sg__IndexOf(arg1,(unsigned int const &)*arg2);
93895     } catch (std::out_of_range& e) {
93896       {
93897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93898       };
93899     } catch (std::exception& e) {
93900       {
93901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93902       };
93903     } catch (Dali::DaliException e) {
93904       {
93905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93906       };
93907     } catch (...) {
93908       {
93909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93910       };
93911     }
93912   }
93913
93914   jresult = result;
93915   return jresult;
93916 }
93917
93918
93919 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_LastIndexOf(void * jarg1, unsigned int jarg2) {
93920   int jresult ;
93921   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93922   unsigned int *arg2 = 0 ;
93923   unsigned int temp2 ;
93924   int result;
93925
93926   arg1 = (std::vector< unsigned int > *)jarg1;
93927   temp2 = (unsigned int)jarg2;
93928   arg2 = &temp2;
93929   {
93930     try {
93931       result = (int)std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(arg1,(unsigned int const &)*arg2);
93932     } catch (std::out_of_range& e) {
93933       {
93934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93935       };
93936     } catch (std::exception& e) {
93937       {
93938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93939       };
93940     } catch (Dali::DaliException e) {
93941       {
93942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93943       };
93944     } catch (...) {
93945       {
93946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93947       };
93948     }
93949   }
93950
93951   jresult = result;
93952   return jresult;
93953 }
93954
93955
93956 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Remove(void * jarg1, unsigned int jarg2) {
93957   unsigned int jresult ;
93958   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93959   unsigned int *arg2 = 0 ;
93960   unsigned int temp2 ;
93961   bool result;
93962
93963   arg1 = (std::vector< unsigned int > *)jarg1;
93964   temp2 = (unsigned int)jarg2;
93965   arg2 = &temp2;
93966   {
93967     try {
93968       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Remove(arg1,(unsigned int const &)*arg2);
93969     } catch (std::out_of_range& e) {
93970       {
93971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93972       };
93973     } catch (std::exception& e) {
93974       {
93975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93976       };
93977     } catch (Dali::DaliException e) {
93978       {
93979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93980       };
93981     } catch (...) {
93982       {
93983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93984       };
93985     }
93986   }
93987
93988   jresult = result;
93989   return jresult;
93990 }
93991
93992
93993 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemIdContainer(void * jarg1) {
93994   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93995
93996   arg1 = (std::vector< unsigned int > *)jarg1;
93997   {
93998     try {
93999       delete arg1;
94000     } catch (std::out_of_range& e) {
94001       {
94002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94003       };
94004     } catch (std::exception& e) {
94005       {
94006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94007       };
94008     } catch (Dali::DaliException e) {
94009       {
94010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94011       };
94012     } catch (...) {
94013       {
94014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94015       };
94016     }
94017   }
94018
94019 }
94020
94021
94022 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_0() {
94023   void * jresult ;
94024   std::pair< unsigned int,Dali::Actor > *result = 0 ;
94025
94026   {
94027     try {
94028       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >();
94029     } catch (std::out_of_range& e) {
94030       {
94031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94032       };
94033     } catch (std::exception& e) {
94034       {
94035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94036       };
94037     } catch (Dali::DaliException e) {
94038       {
94039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94040       };
94041     } catch (...) {
94042       {
94043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94044       };
94045     }
94046   }
94047
94048   jresult = (void *)result;
94049   return jresult;
94050 }
94051
94052
94053 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_1(unsigned int jarg1, void * jarg2) {
94054   void * jresult ;
94055   unsigned int arg1 ;
94056   Dali::Actor arg2 ;
94057   Dali::Actor *argp2 ;
94058   std::pair< unsigned int,Dali::Actor > *result = 0 ;
94059
94060   arg1 = (unsigned int)jarg1;
94061   argp2 = (Dali::Actor *)jarg2;
94062   if (!argp2) {
94063     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
94064     return 0;
94065   }
94066   arg2 = *argp2;
94067   {
94068     try {
94069       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >(arg1,arg2);
94070     } catch (std::out_of_range& e) {
94071       {
94072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94073       };
94074     } catch (std::exception& e) {
94075       {
94076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94077       };
94078     } catch (Dali::DaliException e) {
94079       {
94080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94081       };
94082     } catch (...) {
94083       {
94084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94085       };
94086     }
94087   }
94088
94089   jresult = (void *)result;
94090   return jresult;
94091 }
94092
94093
94094 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_2(void * jarg1) {
94095   void * jresult ;
94096   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
94097   std::pair< unsigned int,Dali::Actor > *result = 0 ;
94098
94099   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
94100   if (!arg1) {
94101     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
94102     return 0;
94103   }
94104   {
94105     try {
94106       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >((std::pair< unsigned int,Dali::Actor > const &)*arg1);
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 = (void *)result;
94127   return jresult;
94128 }
94129
94130
94131 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_first_set(void * jarg1, unsigned int jarg2) {
94132   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
94133   unsigned int arg2 ;
94134
94135   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
94136   arg2 = (unsigned int)jarg2;
94137   if (arg1) (arg1)->first = arg2;
94138 }
94139
94140
94141 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Item_first_get(void * jarg1) {
94142   unsigned int jresult ;
94143   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
94144   unsigned int result;
94145
94146   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
94147   result = (unsigned int) ((arg1)->first);
94148   jresult = result;
94149   return jresult;
94150 }
94151
94152
94153 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_second_set(void * jarg1, void * jarg2) {
94154   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
94155   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
94156
94157   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
94158   arg2 = (Dali::Actor *)jarg2;
94159   if (arg1) (arg1)->second = *arg2;
94160 }
94161
94162
94163 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Item_second_get(void * jarg1) {
94164   void * jresult ;
94165   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
94166   Dali::Actor *result = 0 ;
94167
94168   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
94169   result = (Dali::Actor *)& ((arg1)->second);
94170   jresult = (void *)result;
94171   return jresult;
94172 }
94173
94174
94175 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Item(void * jarg1) {
94176   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
94177
94178   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
94179   {
94180     try {
94181       delete arg1;
94182     } catch (std::out_of_range& e) {
94183       {
94184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94185       };
94186     } catch (std::exception& e) {
94187       {
94188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94189       };
94190     } catch (Dali::DaliException e) {
94191       {
94192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94193       };
94194     } catch (...) {
94195       {
94196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94197       };
94198     }
94199   }
94200
94201 }
94202
94203
94204 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Clear(void * jarg1) {
94205   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94206
94207   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94208   {
94209     try {
94210       (arg1)->clear();
94211     } catch (std::out_of_range& e) {
94212       {
94213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94214       };
94215     } catch (std::exception& e) {
94216       {
94217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94218       };
94219     } catch (Dali::DaliException e) {
94220       {
94221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94222       };
94223     } catch (...) {
94224       {
94225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94226       };
94227     }
94228   }
94229
94230 }
94231
94232
94233 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Add(void * jarg1, void * jarg2) {
94234   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94235   std::pair< unsigned int,Dali::Actor > *arg2 = 0 ;
94236
94237   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94238   arg2 = (std::pair< unsigned int,Dali::Actor > *)jarg2;
94239   if (!arg2) {
94240     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
94241     return ;
94242   }
94243   {
94244     try {
94245       (arg1)->push_back((std::pair< unsigned int,Dali::Actor > const &)*arg2);
94246     } catch (std::out_of_range& e) {
94247       {
94248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94249       };
94250     } catch (std::exception& e) {
94251       {
94252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94253       };
94254     } catch (Dali::DaliException e) {
94255       {
94256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94257       };
94258     } catch (...) {
94259       {
94260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94261       };
94262     }
94263   }
94264
94265 }
94266
94267
94268 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_size(void * jarg1) {
94269   unsigned long jresult ;
94270   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94271   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
94272
94273   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94274   {
94275     try {
94276       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->size();
94277     } catch (std::out_of_range& e) {
94278       {
94279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94280       };
94281     } catch (std::exception& e) {
94282       {
94283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94284       };
94285     } catch (Dali::DaliException e) {
94286       {
94287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94288       };
94289     } catch (...) {
94290       {
94291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94292       };
94293     }
94294   }
94295
94296   jresult = (unsigned long)result;
94297   return jresult;
94298 }
94299
94300
94301 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_capacity(void * jarg1) {
94302   unsigned long jresult ;
94303   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94304   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
94305
94306   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94307   {
94308     try {
94309       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->capacity();
94310     } catch (std::out_of_range& e) {
94311       {
94312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94313       };
94314     } catch (std::exception& e) {
94315       {
94316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94317       };
94318     } catch (Dali::DaliException e) {
94319       {
94320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94321       };
94322     } catch (...) {
94323       {
94324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94325       };
94326     }
94327   }
94328
94329   jresult = (unsigned long)result;
94330   return jresult;
94331 }
94332
94333
94334 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_reserve(void * jarg1, unsigned long jarg2) {
94335   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94336   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type arg2 ;
94337
94338   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94339   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > >::size_type)jarg2;
94340   {
94341     try {
94342       (arg1)->reserve(arg2);
94343     } catch (std::out_of_range& e) {
94344       {
94345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94346       };
94347     } catch (std::exception& e) {
94348       {
94349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94350       };
94351     } catch (Dali::DaliException e) {
94352       {
94353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94354       };
94355     } catch (...) {
94356       {
94357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94358       };
94359     }
94360   }
94361
94362 }
94363
94364
94365 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_0() {
94366   void * jresult ;
94367   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
94368
94369   {
94370     try {
94371       result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)new std::vector< std::pair< unsigned int,Dali::Actor > >();
94372     } catch (std::out_of_range& e) {
94373       {
94374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94375       };
94376     } catch (std::exception& e) {
94377       {
94378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94379       };
94380     } catch (Dali::DaliException e) {
94381       {
94382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94383       };
94384     } catch (...) {
94385       {
94386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94387       };
94388     }
94389   }
94390
94391   jresult = (void *)result;
94392   return jresult;
94393 }
94394
94395
94396 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_1(void * jarg1) {
94397   void * jresult ;
94398   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = 0 ;
94399   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
94400
94401   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94402   if (!arg1) {
94403     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
94404     return 0;
94405   }
94406   {
94407     try {
94408       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);
94409     } catch (std::out_of_range& e) {
94410       {
94411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94412       };
94413     } catch (std::exception& e) {
94414       {
94415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94416       };
94417     } catch (Dali::DaliException e) {
94418       {
94419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94420       };
94421     } catch (...) {
94422       {
94423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94424       };
94425     }
94426   }
94427
94428   jresult = (void *)result;
94429   return jresult;
94430 }
94431
94432
94433 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_2(int jarg1) {
94434   void * jresult ;
94435   int arg1 ;
94436   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
94437
94438   arg1 = (int)jarg1;
94439   {
94440     try {
94441       try {
94442         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);
94443       }
94444       catch(std::out_of_range &_e) {
94445         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94446         return 0;
94447       }
94448
94449     } catch (std::out_of_range& e) {
94450       {
94451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94452       };
94453     } catch (std::exception& e) {
94454       {
94455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94456       };
94457     } catch (Dali::DaliException e) {
94458       {
94459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94460       };
94461     } catch (...) {
94462       {
94463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94464       };
94465     }
94466   }
94467
94468   jresult = (void *)result;
94469   return jresult;
94470 }
94471
94472
94473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitemcopy(void * jarg1, int jarg2) {
94474   void * jresult ;
94475   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94476   int arg2 ;
94477   std::pair< unsigned int,Dali::Actor > result;
94478
94479   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94480   arg2 = (int)jarg2;
94481   {
94482     try {
94483       try {
94484         result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(arg1,arg2);
94485       }
94486       catch(std::out_of_range &_e) {
94487         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94488         return 0;
94489       }
94490
94491     } catch (std::out_of_range& e) {
94492       {
94493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94494       };
94495     } catch (std::exception& e) {
94496       {
94497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94498       };
94499     } catch (Dali::DaliException e) {
94500       {
94501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94502       };
94503     } catch (...) {
94504       {
94505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94506       };
94507     }
94508   }
94509
94510   jresult = new std::pair< unsigned int,Dali::Actor >((const std::pair< unsigned int,Dali::Actor > &)result);
94511   return jresult;
94512 }
94513
94514
94515 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitem(void * jarg1, int jarg2) {
94516   void * jresult ;
94517   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94518   int arg2 ;
94519   std::pair< unsigned int,Dali::Actor > *result = 0 ;
94520
94521   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94522   arg2 = (int)jarg2;
94523   {
94524     try {
94525       try {
94526         result = (std::pair< unsigned int,Dali::Actor > *) &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(arg1,arg2);
94527       }
94528       catch(std::out_of_range &_e) {
94529         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94530         return 0;
94531       }
94532
94533     } catch (std::out_of_range& e) {
94534       {
94535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94536       };
94537     } catch (std::exception& e) {
94538       {
94539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94540       };
94541     } catch (Dali::DaliException e) {
94542       {
94543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94544       };
94545     } catch (...) {
94546       {
94547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94548       };
94549     }
94550   }
94551
94552   jresult = (void *)result;
94553   return jresult;
94554 }
94555
94556
94557 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
94558   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94559   int arg2 ;
94560   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
94561
94562   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94563   arg2 = (int)jarg2;
94564   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
94565   if (!arg3) {
94566     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
94567     return ;
94568   }
94569   {
94570     try {
94571       try {
94572         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);
94573       }
94574       catch(std::out_of_range &_e) {
94575         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94576         return ;
94577       }
94578
94579     } catch (std::out_of_range& e) {
94580       {
94581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94582       };
94583     } catch (std::exception& e) {
94584       {
94585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94586       };
94587     } catch (Dali::DaliException e) {
94588       {
94589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94590       };
94591     } catch (...) {
94592       {
94593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94594       };
94595     }
94596   }
94597
94598 }
94599
94600
94601 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_AddRange(void * jarg1, void * jarg2) {
94602   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94603   std::vector< std::pair< unsigned int,Dali::Actor > > *arg2 = 0 ;
94604
94605   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94606   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg2;
94607   if (!arg2) {
94608     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
94609     return ;
94610   }
94611   {
94612     try {
94613       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);
94614     } catch (std::out_of_range& e) {
94615       {
94616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94617       };
94618     } catch (std::exception& e) {
94619       {
94620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94621       };
94622     } catch (Dali::DaliException e) {
94623       {
94624         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94625       };
94626     } catch (...) {
94627       {
94628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94629       };
94630     }
94631   }
94632
94633 }
94634
94635
94636 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
94637   void * jresult ;
94638   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94639   int arg2 ;
94640   int arg3 ;
94641   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
94642
94643   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94644   arg2 = (int)jarg2;
94645   arg3 = (int)jarg3;
94646   {
94647     try {
94648       try {
94649         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);
94650       }
94651       catch(std::out_of_range &_e) {
94652         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94653         return 0;
94654       }
94655       catch(std::invalid_argument &_e) {
94656         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
94657         return 0;
94658       }
94659
94660     } catch (std::out_of_range& e) {
94661       {
94662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94663       };
94664     } catch (std::exception& e) {
94665       {
94666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94667       };
94668     } catch (Dali::DaliException e) {
94669       {
94670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94671       };
94672     } catch (...) {
94673       {
94674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94675       };
94676     }
94677   }
94678
94679   jresult = (void *)result;
94680   return jresult;
94681 }
94682
94683
94684 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
94685   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94686   int arg2 ;
94687   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
94688
94689   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94690   arg2 = (int)jarg2;
94691   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
94692   if (!arg3) {
94693     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
94694     return ;
94695   }
94696   {
94697     try {
94698       try {
94699         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);
94700       }
94701       catch(std::out_of_range &_e) {
94702         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94703         return ;
94704       }
94705
94706     } catch (std::out_of_range& e) {
94707       {
94708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94709       };
94710     } catch (std::exception& e) {
94711       {
94712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94713       };
94714     } catch (Dali::DaliException e) {
94715       {
94716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94717       };
94718     } catch (...) {
94719       {
94720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94721       };
94722     }
94723   }
94724
94725 }
94726
94727
94728 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
94729   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94730   int arg2 ;
94731   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
94732
94733   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94734   arg2 = (int)jarg2;
94735   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
94736   if (!arg3) {
94737     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
94738     return ;
94739   }
94740   {
94741     try {
94742       try {
94743         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);
94744       }
94745       catch(std::out_of_range &_e) {
94746         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94747         return ;
94748       }
94749
94750     } catch (std::out_of_range& e) {
94751       {
94752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94753       };
94754     } catch (std::exception& e) {
94755       {
94756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94757       };
94758     } catch (Dali::DaliException e) {
94759       {
94760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94761       };
94762     } catch (...) {
94763       {
94764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94765       };
94766     }
94767   }
94768
94769 }
94770
94771
94772 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveAt(void * jarg1, int jarg2) {
94773   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94774   int arg2 ;
94775
94776   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94777   arg2 = (int)jarg2;
94778   {
94779     try {
94780       try {
94781         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(arg1,arg2);
94782       }
94783       catch(std::out_of_range &_e) {
94784         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94785         return ;
94786       }
94787
94788     } catch (std::out_of_range& e) {
94789       {
94790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94791       };
94792     } catch (std::exception& e) {
94793       {
94794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94795       };
94796     } catch (Dali::DaliException e) {
94797       {
94798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94799       };
94800     } catch (...) {
94801       {
94802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94803       };
94804     }
94805   }
94806
94807 }
94808
94809
94810 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
94811   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94812   int arg2 ;
94813   int arg3 ;
94814
94815   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94816   arg2 = (int)jarg2;
94817   arg3 = (int)jarg3;
94818   {
94819     try {
94820       try {
94821         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(arg1,arg2,arg3);
94822       }
94823       catch(std::out_of_range &_e) {
94824         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94825         return ;
94826       }
94827       catch(std::invalid_argument &_e) {
94828         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
94829         return ;
94830       }
94831
94832     } catch (std::out_of_range& e) {
94833       {
94834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94835       };
94836     } catch (std::exception& e) {
94837       {
94838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94839       };
94840     } catch (Dali::DaliException e) {
94841       {
94842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94843       };
94844     } catch (...) {
94845       {
94846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94847       };
94848     }
94849   }
94850
94851 }
94852
94853
94854 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_Repeat(void * jarg1, int jarg2) {
94855   void * jresult ;
94856   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
94857   int arg2 ;
94858   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
94859
94860   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
94861   if (!arg1) {
94862     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
94863     return 0;
94864   }
94865   arg2 = (int)jarg2;
94866   {
94867     try {
94868       try {
94869         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);
94870       }
94871       catch(std::out_of_range &_e) {
94872         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94873         return 0;
94874       }
94875
94876     } catch (std::out_of_range& e) {
94877       {
94878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94879       };
94880     } catch (std::exception& e) {
94881       {
94882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94883       };
94884     } catch (Dali::DaliException e) {
94885       {
94886         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94887       };
94888     } catch (...) {
94889       {
94890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94891       };
94892     }
94893   }
94894
94895   jresult = (void *)result;
94896   return jresult;
94897 }
94898
94899
94900 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_0(void * jarg1) {
94901   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94902
94903   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94904   {
94905     try {
94906       std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(arg1);
94907     } catch (std::out_of_range& e) {
94908       {
94909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94910       };
94911     } catch (std::exception& e) {
94912       {
94913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94914       };
94915     } catch (Dali::DaliException e) {
94916       {
94917         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94918       };
94919     } catch (...) {
94920       {
94921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94922       };
94923     }
94924   }
94925
94926 }
94927
94928
94929 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
94930   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94931   int arg2 ;
94932   int arg3 ;
94933
94934   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94935   arg2 = (int)jarg2;
94936   arg3 = (int)jarg3;
94937   {
94938     try {
94939       try {
94940         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
94941       }
94942       catch(std::out_of_range &_e) {
94943         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94944         return ;
94945       }
94946       catch(std::invalid_argument &_e) {
94947         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
94948         return ;
94949       }
94950
94951     } catch (std::out_of_range& e) {
94952       {
94953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94954       };
94955     } catch (std::exception& e) {
94956       {
94957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94958       };
94959     } catch (Dali::DaliException e) {
94960       {
94961         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94962       };
94963     } catch (...) {
94964       {
94965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94966       };
94967     }
94968   }
94969
94970 }
94971
94972
94973 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
94974   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94975   int arg2 ;
94976   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
94977
94978   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94979   arg2 = (int)jarg2;
94980   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
94981   if (!arg3) {
94982     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
94983     return ;
94984   }
94985   {
94986     try {
94987       try {
94988         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);
94989       }
94990       catch(std::out_of_range &_e) {
94991         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94992         return ;
94993       }
94994
94995     } catch (std::out_of_range& e) {
94996       {
94997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94998       };
94999     } catch (std::exception& e) {
95000       {
95001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95002       };
95003     } catch (Dali::DaliException e) {
95004       {
95005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95006       };
95007     } catch (...) {
95008       {
95009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95010       };
95011     }
95012   }
95013
95014 }
95015
95016
95017 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemContainer(void * jarg1) {
95018   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
95019
95020   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
95021   {
95022     try {
95023       delete arg1;
95024     } catch (std::out_of_range& e) {
95025       {
95026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95027       };
95028     } catch (std::exception& e) {
95029       {
95030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95031       };
95032     } catch (Dali::DaliException e) {
95033       {
95034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95035       };
95036     } catch (...) {
95037       {
95038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95039       };
95040     }
95041   }
95042
95043 }
95044
95045
95046 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Clear(void * jarg1) {
95047   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95048
95049   arg1 = (std::vector< Dali::Actor > *)jarg1;
95050   {
95051     try {
95052       (arg1)->clear();
95053     } catch (std::out_of_range& e) {
95054       {
95055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95056       };
95057     } catch (std::exception& e) {
95058       {
95059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95060       };
95061     } catch (Dali::DaliException e) {
95062       {
95063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95064       };
95065     } catch (...) {
95066       {
95067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95068       };
95069     }
95070   }
95071
95072 }
95073
95074
95075 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Add(void * jarg1, void * jarg2) {
95076   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95077   Dali::Actor *arg2 = 0 ;
95078
95079   arg1 = (std::vector< Dali::Actor > *)jarg1;
95080   arg2 = (Dali::Actor *)jarg2;
95081   if (!arg2) {
95082     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
95083     return ;
95084   }
95085   {
95086     try {
95087       (arg1)->push_back((Dali::Actor const &)*arg2);
95088     } catch (std::out_of_range& e) {
95089       {
95090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95091       };
95092     } catch (std::exception& e) {
95093       {
95094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95095       };
95096     } catch (Dali::DaliException e) {
95097       {
95098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95099       };
95100     } catch (...) {
95101       {
95102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95103       };
95104     }
95105   }
95106
95107 }
95108
95109
95110 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_size(void * jarg1) {
95111   unsigned long jresult ;
95112   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95113   std::vector< Dali::Actor >::size_type result;
95114
95115   arg1 = (std::vector< Dali::Actor > *)jarg1;
95116   {
95117     try {
95118       result = ((std::vector< Dali::Actor > const *)arg1)->size();
95119     } catch (std::out_of_range& e) {
95120       {
95121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95122       };
95123     } catch (std::exception& e) {
95124       {
95125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95126       };
95127     } catch (Dali::DaliException e) {
95128       {
95129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95130       };
95131     } catch (...) {
95132       {
95133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95134       };
95135     }
95136   }
95137
95138   jresult = (unsigned long)result;
95139   return jresult;
95140 }
95141
95142
95143 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_capacity(void * jarg1) {
95144   unsigned long jresult ;
95145   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95146   std::vector< Dali::Actor >::size_type result;
95147
95148   arg1 = (std::vector< Dali::Actor > *)jarg1;
95149   {
95150     try {
95151       result = ((std::vector< Dali::Actor > const *)arg1)->capacity();
95152     } catch (std::out_of_range& e) {
95153       {
95154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95155       };
95156     } catch (std::exception& e) {
95157       {
95158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95159       };
95160     } catch (Dali::DaliException e) {
95161       {
95162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95163       };
95164     } catch (...) {
95165       {
95166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95167       };
95168     }
95169   }
95170
95171   jresult = (unsigned long)result;
95172   return jresult;
95173 }
95174
95175
95176 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_reserve(void * jarg1, unsigned long jarg2) {
95177   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95178   std::vector< Dali::Actor >::size_type arg2 ;
95179
95180   arg1 = (std::vector< Dali::Actor > *)jarg1;
95181   arg2 = (std::vector< Dali::Actor >::size_type)jarg2;
95182   {
95183     try {
95184       (arg1)->reserve(arg2);
95185     } catch (std::out_of_range& e) {
95186       {
95187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95188       };
95189     } catch (std::exception& e) {
95190       {
95191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95192       };
95193     } catch (Dali::DaliException e) {
95194       {
95195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95196       };
95197     } catch (...) {
95198       {
95199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95200       };
95201     }
95202   }
95203
95204 }
95205
95206
95207 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_0() {
95208   void * jresult ;
95209   std::vector< Dali::Actor > *result = 0 ;
95210
95211   {
95212     try {
95213       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >();
95214     } catch (std::out_of_range& e) {
95215       {
95216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95217       };
95218     } catch (std::exception& e) {
95219       {
95220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95221       };
95222     } catch (Dali::DaliException e) {
95223       {
95224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95225       };
95226     } catch (...) {
95227       {
95228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95229       };
95230     }
95231   }
95232
95233   jresult = (void *)result;
95234   return jresult;
95235 }
95236
95237
95238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_1(void * jarg1) {
95239   void * jresult ;
95240   std::vector< Dali::Actor > *arg1 = 0 ;
95241   std::vector< Dali::Actor > *result = 0 ;
95242
95243   arg1 = (std::vector< Dali::Actor > *)jarg1;
95244   if (!arg1) {
95245     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
95246     return 0;
95247   }
95248   {
95249     try {
95250       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >((std::vector< Dali::Actor > const &)*arg1);
95251     } catch (std::out_of_range& e) {
95252       {
95253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95254       };
95255     } catch (std::exception& e) {
95256       {
95257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95258       };
95259     } catch (Dali::DaliException e) {
95260       {
95261         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95262       };
95263     } catch (...) {
95264       {
95265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95266       };
95267     }
95268   }
95269
95270   jresult = (void *)result;
95271   return jresult;
95272 }
95273
95274
95275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_2(int jarg1) {
95276   void * jresult ;
95277   int arg1 ;
95278   std::vector< Dali::Actor > *result = 0 ;
95279
95280   arg1 = (int)jarg1;
95281   {
95282     try {
95283       try {
95284         result = (std::vector< Dali::Actor > *)new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(arg1);
95285       }
95286       catch(std::out_of_range &_e) {
95287         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95288         return 0;
95289       }
95290
95291     } catch (std::out_of_range& e) {
95292       {
95293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95294       };
95295     } catch (std::exception& e) {
95296       {
95297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95298       };
95299     } catch (Dali::DaliException e) {
95300       {
95301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95302       };
95303     } catch (...) {
95304       {
95305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95306       };
95307     }
95308   }
95309
95310   jresult = (void *)result;
95311   return jresult;
95312 }
95313
95314
95315 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitemcopy(void * jarg1, int jarg2) {
95316   void * jresult ;
95317   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95318   int arg2 ;
95319   Dali::Actor result;
95320
95321   arg1 = (std::vector< Dali::Actor > *)jarg1;
95322   arg2 = (int)jarg2;
95323   {
95324     try {
95325       try {
95326         result = std_vector_Sl_Dali_Actor_Sg__getitemcopy(arg1,arg2);
95327       }
95328       catch(std::out_of_range &_e) {
95329         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95330         return 0;
95331       }
95332
95333     } catch (std::out_of_range& e) {
95334       {
95335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95336       };
95337     } catch (std::exception& e) {
95338       {
95339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95340       };
95341     } catch (Dali::DaliException e) {
95342       {
95343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95344       };
95345     } catch (...) {
95346       {
95347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95348       };
95349     }
95350   }
95351
95352   jresult = new Dali::Actor((const Dali::Actor &)result);
95353   return jresult;
95354 }
95355
95356
95357 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitem(void * jarg1, int jarg2) {
95358   void * jresult ;
95359   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95360   int arg2 ;
95361   Dali::Actor *result = 0 ;
95362
95363   arg1 = (std::vector< Dali::Actor > *)jarg1;
95364   arg2 = (int)jarg2;
95365   {
95366     try {
95367       try {
95368         result = (Dali::Actor *) &std_vector_Sl_Dali_Actor_Sg__getitem(arg1,arg2);
95369       }
95370       catch(std::out_of_range &_e) {
95371         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95372         return 0;
95373       }
95374
95375     } catch (std::out_of_range& e) {
95376       {
95377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95378       };
95379     } catch (std::exception& e) {
95380       {
95381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95382       };
95383     } catch (Dali::DaliException e) {
95384       {
95385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95386       };
95387     } catch (...) {
95388       {
95389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95390       };
95391     }
95392   }
95393
95394   jresult = (void *)result;
95395   return jresult;
95396 }
95397
95398
95399 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
95400   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95401   int arg2 ;
95402   Dali::Actor *arg3 = 0 ;
95403
95404   arg1 = (std::vector< Dali::Actor > *)jarg1;
95405   arg2 = (int)jarg2;
95406   arg3 = (Dali::Actor *)jarg3;
95407   if (!arg3) {
95408     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
95409     return ;
95410   }
95411   {
95412     try {
95413       try {
95414         std_vector_Sl_Dali_Actor_Sg__setitem(arg1,arg2,(Dali::Actor const &)*arg3);
95415       }
95416       catch(std::out_of_range &_e) {
95417         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95418         return ;
95419       }
95420
95421     } catch (std::out_of_range& e) {
95422       {
95423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95424       };
95425     } catch (std::exception& e) {
95426       {
95427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95428       };
95429     } catch (Dali::DaliException e) {
95430       {
95431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95432       };
95433     } catch (...) {
95434       {
95435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95436       };
95437     }
95438   }
95439
95440 }
95441
95442
95443 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_AddRange(void * jarg1, void * jarg2) {
95444   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95445   std::vector< Dali::Actor > *arg2 = 0 ;
95446
95447   arg1 = (std::vector< Dali::Actor > *)jarg1;
95448   arg2 = (std::vector< Dali::Actor > *)jarg2;
95449   if (!arg2) {
95450     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
95451     return ;
95452   }
95453   {
95454     try {
95455       std_vector_Sl_Dali_Actor_Sg__AddRange(arg1,(std::vector< Dali::Actor > const &)*arg2);
95456     } catch (std::out_of_range& e) {
95457       {
95458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95459       };
95460     } catch (std::exception& e) {
95461       {
95462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95463       };
95464     } catch (Dali::DaliException e) {
95465       {
95466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95467       };
95468     } catch (...) {
95469       {
95470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95471       };
95472     }
95473   }
95474
95475 }
95476
95477
95478 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
95479   void * jresult ;
95480   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95481   int arg2 ;
95482   int arg3 ;
95483   std::vector< Dali::Actor > *result = 0 ;
95484
95485   arg1 = (std::vector< Dali::Actor > *)jarg1;
95486   arg2 = (int)jarg2;
95487   arg3 = (int)jarg3;
95488   {
95489     try {
95490       try {
95491         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__GetRange(arg1,arg2,arg3);
95492       }
95493       catch(std::out_of_range &_e) {
95494         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95495         return 0;
95496       }
95497       catch(std::invalid_argument &_e) {
95498         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
95499         return 0;
95500       }
95501
95502     } catch (std::out_of_range& e) {
95503       {
95504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95505       };
95506     } catch (std::exception& e) {
95507       {
95508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95509       };
95510     } catch (Dali::DaliException e) {
95511       {
95512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95513       };
95514     } catch (...) {
95515       {
95516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95517       };
95518     }
95519   }
95520
95521   jresult = (void *)result;
95522   return jresult;
95523 }
95524
95525
95526 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
95527   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95528   int arg2 ;
95529   Dali::Actor *arg3 = 0 ;
95530
95531   arg1 = (std::vector< Dali::Actor > *)jarg1;
95532   arg2 = (int)jarg2;
95533   arg3 = (Dali::Actor *)jarg3;
95534   if (!arg3) {
95535     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
95536     return ;
95537   }
95538   {
95539     try {
95540       try {
95541         std_vector_Sl_Dali_Actor_Sg__Insert(arg1,arg2,(Dali::Actor const &)*arg3);
95542       }
95543       catch(std::out_of_range &_e) {
95544         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95545         return ;
95546       }
95547
95548     } catch (std::out_of_range& e) {
95549       {
95550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95551       };
95552     } catch (std::exception& e) {
95553       {
95554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95555       };
95556     } catch (Dali::DaliException e) {
95557       {
95558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95559       };
95560     } catch (...) {
95561       {
95562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95563       };
95564     }
95565   }
95566
95567 }
95568
95569
95570 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
95571   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95572   int arg2 ;
95573   std::vector< Dali::Actor > *arg3 = 0 ;
95574
95575   arg1 = (std::vector< Dali::Actor > *)jarg1;
95576   arg2 = (int)jarg2;
95577   arg3 = (std::vector< Dali::Actor > *)jarg3;
95578   if (!arg3) {
95579     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
95580     return ;
95581   }
95582   {
95583     try {
95584       try {
95585         std_vector_Sl_Dali_Actor_Sg__InsertRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
95586       }
95587       catch(std::out_of_range &_e) {
95588         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95589         return ;
95590       }
95591
95592     } catch (std::out_of_range& e) {
95593       {
95594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95595       };
95596     } catch (std::exception& e) {
95597       {
95598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95599       };
95600     } catch (Dali::DaliException e) {
95601       {
95602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95603       };
95604     } catch (...) {
95605       {
95606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95607       };
95608     }
95609   }
95610
95611 }
95612
95613
95614 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveAt(void * jarg1, int jarg2) {
95615   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95616   int arg2 ;
95617
95618   arg1 = (std::vector< Dali::Actor > *)jarg1;
95619   arg2 = (int)jarg2;
95620   {
95621     try {
95622       try {
95623         std_vector_Sl_Dali_Actor_Sg__RemoveAt(arg1,arg2);
95624       }
95625       catch(std::out_of_range &_e) {
95626         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95627         return ;
95628       }
95629
95630     } catch (std::out_of_range& e) {
95631       {
95632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95633       };
95634     } catch (std::exception& e) {
95635       {
95636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95637       };
95638     } catch (Dali::DaliException e) {
95639       {
95640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95641       };
95642     } catch (...) {
95643       {
95644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95645       };
95646     }
95647   }
95648
95649 }
95650
95651
95652 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
95653   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95654   int arg2 ;
95655   int arg3 ;
95656
95657   arg1 = (std::vector< Dali::Actor > *)jarg1;
95658   arg2 = (int)jarg2;
95659   arg3 = (int)jarg3;
95660   {
95661     try {
95662       try {
95663         std_vector_Sl_Dali_Actor_Sg__RemoveRange(arg1,arg2,arg3);
95664       }
95665       catch(std::out_of_range &_e) {
95666         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95667         return ;
95668       }
95669       catch(std::invalid_argument &_e) {
95670         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
95671         return ;
95672       }
95673
95674     } catch (std::out_of_range& e) {
95675       {
95676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95677       };
95678     } catch (std::exception& e) {
95679       {
95680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95681       };
95682     } catch (Dali::DaliException e) {
95683       {
95684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95685       };
95686     } catch (...) {
95687       {
95688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95689       };
95690     }
95691   }
95692
95693 }
95694
95695
95696 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_Repeat(void * jarg1, int jarg2) {
95697   void * jresult ;
95698   Dali::Actor *arg1 = 0 ;
95699   int arg2 ;
95700   std::vector< Dali::Actor > *result = 0 ;
95701
95702   arg1 = (Dali::Actor *)jarg1;
95703   if (!arg1) {
95704     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
95705     return 0;
95706   }
95707   arg2 = (int)jarg2;
95708   {
95709     try {
95710       try {
95711         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__Repeat((Dali::Actor const &)*arg1,arg2);
95712       }
95713       catch(std::out_of_range &_e) {
95714         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95715         return 0;
95716       }
95717
95718     } catch (std::out_of_range& e) {
95719       {
95720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95721       };
95722     } catch (std::exception& e) {
95723       {
95724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95725       };
95726     } catch (Dali::DaliException e) {
95727       {
95728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95729       };
95730     } catch (...) {
95731       {
95732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95733       };
95734     }
95735   }
95736
95737   jresult = (void *)result;
95738   return jresult;
95739 }
95740
95741
95742 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_0(void * jarg1) {
95743   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95744
95745   arg1 = (std::vector< Dali::Actor > *)jarg1;
95746   {
95747     try {
95748       std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(arg1);
95749     } catch (std::out_of_range& e) {
95750       {
95751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95752       };
95753     } catch (std::exception& e) {
95754       {
95755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95756       };
95757     } catch (Dali::DaliException e) {
95758       {
95759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95760       };
95761     } catch (...) {
95762       {
95763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95764       };
95765     }
95766   }
95767
95768 }
95769
95770
95771 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
95772   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95773   int arg2 ;
95774   int arg3 ;
95775
95776   arg1 = (std::vector< Dali::Actor > *)jarg1;
95777   arg2 = (int)jarg2;
95778   arg3 = (int)jarg3;
95779   {
95780     try {
95781       try {
95782         std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
95783       }
95784       catch(std::out_of_range &_e) {
95785         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95786         return ;
95787       }
95788       catch(std::invalid_argument &_e) {
95789         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
95790         return ;
95791       }
95792
95793     } catch (std::out_of_range& e) {
95794       {
95795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95796       };
95797     } catch (std::exception& e) {
95798       {
95799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95800       };
95801     } catch (Dali::DaliException e) {
95802       {
95803         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95804       };
95805     } catch (...) {
95806       {
95807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95808       };
95809     }
95810   }
95811
95812 }
95813
95814
95815 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
95816   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95817   int arg2 ;
95818   std::vector< Dali::Actor > *arg3 = 0 ;
95819
95820   arg1 = (std::vector< Dali::Actor > *)jarg1;
95821   arg2 = (int)jarg2;
95822   arg3 = (std::vector< Dali::Actor > *)jarg3;
95823   if (!arg3) {
95824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
95825     return ;
95826   }
95827   {
95828     try {
95829       try {
95830         std_vector_Sl_Dali_Actor_Sg__SetRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
95831       }
95832       catch(std::out_of_range &_e) {
95833         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95834         return ;
95835       }
95836
95837     } catch (std::out_of_range& e) {
95838       {
95839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95840       };
95841     } catch (std::exception& e) {
95842       {
95843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95844       };
95845     } catch (Dali::DaliException e) {
95846       {
95847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95848       };
95849     } catch (...) {
95850       {
95851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95852       };
95853     }
95854   }
95855
95856 }
95857
95858
95859 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorContainer(void * jarg1) {
95860   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95861
95862   arg1 = (std::vector< Dali::Actor > *)jarg1;
95863   {
95864     try {
95865       delete arg1;
95866     } catch (std::out_of_range& e) {
95867       {
95868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95869       };
95870     } catch (std::exception& e) {
95871       {
95872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95873       };
95874     } catch (Dali::DaliException e) {
95875       {
95876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95877       };
95878     } catch (...) {
95879       {
95880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95881       };
95882     }
95883   }
95884
95885 }
95886
95887
95888 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Empty(void * jarg1) {
95889   unsigned int jresult ;
95890   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95891   bool result;
95892
95893   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95894   {
95895     try {
95896       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
95897     } catch (std::out_of_range& e) {
95898       {
95899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95900       };
95901     } catch (std::exception& e) {
95902       {
95903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95904       };
95905     } catch (Dali::DaliException e) {
95906       {
95907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95908       };
95909     } catch (...) {
95910       {
95911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95912       };
95913     }
95914   }
95915
95916   jresult = result;
95917   return jresult;
95918 }
95919
95920
95921 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_GetConnectionCount(void * jarg1) {
95922   unsigned long jresult ;
95923   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95924   std::size_t result;
95925
95926   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95927   {
95928     try {
95929       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
95930     } catch (std::out_of_range& e) {
95931       {
95932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95933       };
95934     } catch (std::exception& e) {
95935       {
95936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95937       };
95938     } catch (Dali::DaliException e) {
95939       {
95940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95941       };
95942     } catch (...) {
95943       {
95944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95945       };
95946     }
95947   }
95948
95949   jresult = (unsigned long)result;
95950   return jresult;
95951 }
95952
95953
95954 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Connect(void * jarg1, void * jarg2) {
95955   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95956   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
95957
95958   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95959   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
95960   {
95961     try {
95962       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(arg1,arg2);
95963     } catch (std::out_of_range& e) {
95964       {
95965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95966       };
95967     } catch (std::exception& e) {
95968       {
95969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95970       };
95971     } catch (Dali::DaliException e) {
95972       {
95973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95974       };
95975     } catch (...) {
95976       {
95977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95978       };
95979     }
95980   }
95981
95982 }
95983
95984
95985 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Disconnect(void * jarg1, void * jarg2) {
95986   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95987   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
95988
95989   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95990   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
95991   {
95992     try {
95993       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(arg1,arg2);
95994     } catch (std::out_of_range& e) {
95995       {
95996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95997       };
95998     } catch (std::exception& e) {
95999       {
96000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96001       };
96002     } catch (Dali::DaliException e) {
96003       {
96004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96005       };
96006     } catch (...) {
96007       {
96008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96009       };
96010     }
96011   }
96012
96013 }
96014
96015
96016 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Emit(void * jarg1, void * jarg2) {
96017   unsigned int jresult ;
96018   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
96019   Dali::Toolkit::AccessibilityManager *arg2 = 0 ;
96020   bool result;
96021
96022   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
96023   arg2 = (Dali::Toolkit::AccessibilityManager *)jarg2;
96024   if (!arg2) {
96025     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AccessibilityManager & type is null", 0);
96026     return 0;
96027   }
96028   {
96029     try {
96030       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(arg1,*arg2);
96031     } catch (std::out_of_range& e) {
96032       {
96033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96034       };
96035     } catch (std::exception& e) {
96036       {
96037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96038       };
96039     } catch (Dali::DaliException e) {
96040       {
96041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96042       };
96043     } catch (...) {
96044       {
96045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96046       };
96047     }
96048   }
96049
96050   jresult = result;
96051   return jresult;
96052 }
96053
96054
96055 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityActionSignal() {
96056   void * jresult ;
96057   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *result = 0 ;
96058
96059   {
96060     try {
96061       result = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)new Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) >();
96062     } catch (std::out_of_range& e) {
96063       {
96064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96065       };
96066     } catch (std::exception& e) {
96067       {
96068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96069       };
96070     } catch (Dali::DaliException e) {
96071       {
96072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96073       };
96074     } catch (...) {
96075       {
96076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96077       };
96078     }
96079   }
96080
96081   jresult = (void *)result;
96082   return jresult;
96083 }
96084
96085
96086 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityActionSignal(void * jarg1) {
96087   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
96088
96089   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
96090   {
96091     try {
96092       delete arg1;
96093     } catch (std::out_of_range& e) {
96094       {
96095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96096       };
96097     } catch (std::exception& e) {
96098       {
96099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96100       };
96101     } catch (Dali::DaliException e) {
96102       {
96103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96104       };
96105     } catch (...) {
96106       {
96107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96108       };
96109     }
96110   }
96111
96112 }
96113
96114
96115 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Empty(void * jarg1) {
96116   unsigned int jresult ;
96117   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
96118   bool result;
96119
96120   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
96121   {
96122     try {
96123       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);
96124     } catch (std::out_of_range& e) {
96125       {
96126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96127       };
96128     } catch (std::exception& e) {
96129       {
96130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96131       };
96132     } catch (Dali::DaliException e) {
96133       {
96134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96135       };
96136     } catch (...) {
96137       {
96138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96139       };
96140     }
96141   }
96142
96143   jresult = result;
96144   return jresult;
96145 }
96146
96147
96148 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_GetConnectionCount(void * jarg1) {
96149   unsigned long jresult ;
96150   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
96151   std::size_t result;
96152
96153   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
96154   {
96155     try {
96156       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);
96157     } catch (std::out_of_range& e) {
96158       {
96159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96160       };
96161     } catch (std::exception& e) {
96162       {
96163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96164       };
96165     } catch (Dali::DaliException e) {
96166       {
96167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96168       };
96169     } catch (...) {
96170       {
96171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96172       };
96173     }
96174   }
96175
96176   jresult = (unsigned long)result;
96177   return jresult;
96178 }
96179
96180
96181 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Connect(void * jarg1, void * jarg2) {
96182   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
96183   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
96184
96185   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
96186   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
96187   {
96188     try {
96189       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(arg1,arg2);
96190     } catch (std::out_of_range& e) {
96191       {
96192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96193       };
96194     } catch (std::exception& e) {
96195       {
96196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96197       };
96198     } catch (Dali::DaliException e) {
96199       {
96200         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96201       };
96202     } catch (...) {
96203       {
96204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96205       };
96206     }
96207   }
96208
96209 }
96210
96211
96212 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Disconnect(void * jarg1, void * jarg2) {
96213   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
96214   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
96215
96216   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
96217   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
96218   {
96219     try {
96220       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(arg1,arg2);
96221     } catch (std::out_of_range& e) {
96222       {
96223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96224       };
96225     } catch (std::exception& e) {
96226       {
96227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96228       };
96229     } catch (Dali::DaliException e) {
96230       {
96231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96232       };
96233     } catch (...) {
96234       {
96235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96236       };
96237     }
96238   }
96239
96240 }
96241
96242
96243 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
96244   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
96245   Dali::Actor arg2 ;
96246   Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg3 ;
96247   Dali::Actor *argp2 ;
96248
96249   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
96250   argp2 = (Dali::Actor *)jarg2;
96251   if (!argp2) {
96252     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
96253     return ;
96254   }
96255   arg2 = *argp2;
96256   arg3 = (Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)jarg3;
96257   {
96258     try {
96259       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(arg1,arg2,arg3);
96260     } catch (std::out_of_range& e) {
96261       {
96262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96263       };
96264     } catch (std::exception& e) {
96265       {
96266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96267       };
96268     } catch (Dali::DaliException e) {
96269       {
96270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96271       };
96272     } catch (...) {
96273       {
96274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96275       };
96276     }
96277   }
96278
96279 }
96280
96281
96282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityFocusOvershotSignal() {
96283   void * jresult ;
96284   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *result = 0 ;
96285
96286   {
96287     try {
96288       result = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)new Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) >();
96289     } catch (std::out_of_range& e) {
96290       {
96291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96292       };
96293     } catch (std::exception& e) {
96294       {
96295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96296       };
96297     } catch (Dali::DaliException e) {
96298       {
96299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96300       };
96301     } catch (...) {
96302       {
96303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96304       };
96305     }
96306   }
96307
96308   jresult = (void *)result;
96309   return jresult;
96310 }
96311
96312
96313 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityFocusOvershotSignal(void * jarg1) {
96314   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
96315
96316   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
96317   {
96318     try {
96319       delete arg1;
96320     } catch (std::out_of_range& e) {
96321       {
96322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96323       };
96324     } catch (std::exception& e) {
96325       {
96326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96327       };
96328     } catch (Dali::DaliException e) {
96329       {
96330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96331       };
96332     } catch (...) {
96333       {
96334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96335       };
96336     }
96337   }
96338
96339 }
96340
96341
96342 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Empty(void * jarg1) {
96343   unsigned int jresult ;
96344   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
96345   bool result;
96346
96347   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
96348   {
96349     try {
96350       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
96351     } catch (std::out_of_range& e) {
96352       {
96353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96354       };
96355     } catch (std::exception& e) {
96356       {
96357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96358       };
96359     } catch (Dali::DaliException e) {
96360       {
96361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96362       };
96363     } catch (...) {
96364       {
96365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96366       };
96367     }
96368   }
96369
96370   jresult = result;
96371   return jresult;
96372 }
96373
96374
96375 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusChangedSignal_GetConnectionCount(void * jarg1) {
96376   unsigned long jresult ;
96377   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
96378   std::size_t result;
96379
96380   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
96381   {
96382     try {
96383       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
96384     } catch (std::out_of_range& e) {
96385       {
96386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96387       };
96388     } catch (std::exception& e) {
96389       {
96390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96391       };
96392     } catch (Dali::DaliException e) {
96393       {
96394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96395       };
96396     } catch (...) {
96397       {
96398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96399       };
96400     }
96401   }
96402
96403   jresult = (unsigned long)result;
96404   return jresult;
96405 }
96406
96407
96408 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Connect(void * jarg1, void * jarg2) {
96409   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
96410   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
96411
96412   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
96413   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
96414   {
96415     try {
96416       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(arg1,arg2);
96417     } catch (std::out_of_range& e) {
96418       {
96419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96420       };
96421     } catch (std::exception& e) {
96422       {
96423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96424       };
96425     } catch (Dali::DaliException e) {
96426       {
96427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96428       };
96429     } catch (...) {
96430       {
96431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96432       };
96433     }
96434   }
96435
96436 }
96437
96438
96439 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Disconnect(void * jarg1, void * jarg2) {
96440   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
96441   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
96442
96443   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
96444   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
96445   {
96446     try {
96447       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
96448     } catch (std::out_of_range& e) {
96449       {
96450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96451       };
96452     } catch (std::exception& e) {
96453       {
96454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96455       };
96456     } catch (Dali::DaliException e) {
96457       {
96458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96459       };
96460     } catch (...) {
96461       {
96462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96463       };
96464     }
96465   }
96466
96467 }
96468
96469
96470 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
96471   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
96472   Dali::Actor arg2 ;
96473   Dali::Actor arg3 ;
96474   Dali::Actor *argp2 ;
96475   Dali::Actor *argp3 ;
96476
96477   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
96478   argp2 = (Dali::Actor *)jarg2;
96479   if (!argp2) {
96480     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
96481     return ;
96482   }
96483   arg2 = *argp2;
96484   argp3 = (Dali::Actor *)jarg3;
96485   if (!argp3) {
96486     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
96487     return ;
96488   }
96489   arg3 = *argp3;
96490   {
96491     try {
96492       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(arg1,arg2,arg3);
96493     } catch (std::out_of_range& e) {
96494       {
96495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96496       };
96497     } catch (std::exception& e) {
96498       {
96499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96500       };
96501     } catch (Dali::DaliException e) {
96502       {
96503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96504       };
96505     } catch (...) {
96506       {
96507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96508       };
96509     }
96510   }
96511
96512 }
96513
96514
96515 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusChangedSignal() {
96516   void * jresult ;
96517   Dali::Signal< void (Dali::Actor,Dali::Actor) > *result = 0 ;
96518
96519   {
96520     try {
96521       result = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)new Dali::Signal< void (Dali::Actor,Dali::Actor) >();
96522     } catch (std::out_of_range& e) {
96523       {
96524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96525       };
96526     } catch (std::exception& e) {
96527       {
96528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96529       };
96530     } catch (Dali::DaliException e) {
96531       {
96532         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96533       };
96534     } catch (...) {
96535       {
96536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96537       };
96538     }
96539   }
96540
96541   jresult = (void *)result;
96542   return jresult;
96543 }
96544
96545
96546 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusChangedSignal(void * jarg1) {
96547   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
96548
96549   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
96550   {
96551     try {
96552       delete arg1;
96553     } catch (std::out_of_range& e) {
96554       {
96555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96556       };
96557     } catch (std::exception& e) {
96558       {
96559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96560       };
96561     } catch (Dali::DaliException e) {
96562       {
96563         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96564       };
96565     } catch (...) {
96566       {
96567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96568       };
96569     }
96570   }
96571
96572 }
96573
96574
96575 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Empty(void * jarg1) {
96576   unsigned int jresult ;
96577   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96578   bool result;
96579
96580   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96581   {
96582     try {
96583       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
96584     } catch (std::out_of_range& e) {
96585       {
96586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96587       };
96588     } catch (std::exception& e) {
96589       {
96590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96591       };
96592     } catch (Dali::DaliException e) {
96593       {
96594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96595       };
96596     } catch (...) {
96597       {
96598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96599       };
96600     }
96601   }
96602
96603   jresult = result;
96604   return jresult;
96605 }
96606
96607
96608 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_GetConnectionCount(void * jarg1) {
96609   unsigned long jresult ;
96610   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96611   std::size_t result;
96612
96613   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96614   {
96615     try {
96616       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
96617     } catch (std::out_of_range& e) {
96618       {
96619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96620       };
96621     } catch (std::exception& e) {
96622       {
96623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96624       };
96625     } catch (Dali::DaliException e) {
96626       {
96627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96628       };
96629     } catch (...) {
96630       {
96631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96632       };
96633     }
96634   }
96635
96636   jresult = (unsigned long)result;
96637   return jresult;
96638 }
96639
96640
96641 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Connect(void * jarg1, void * jarg2) {
96642   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96643   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
96644
96645   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96646   arg2 = (void (*)(Dali::Actor,bool))jarg2;
96647   {
96648     try {
96649       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(arg1,arg2);
96650     } catch (std::out_of_range& e) {
96651       {
96652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96653       };
96654     } catch (std::exception& e) {
96655       {
96656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96657       };
96658     } catch (Dali::DaliException e) {
96659       {
96660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96661       };
96662     } catch (...) {
96663       {
96664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96665       };
96666     }
96667   }
96668
96669 }
96670
96671
96672 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Disconnect(void * jarg1, void * jarg2) {
96673   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96674   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
96675
96676   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96677   arg2 = (void (*)(Dali::Actor,bool))jarg2;
96678   {
96679     try {
96680       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
96681     } catch (std::out_of_range& e) {
96682       {
96683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96684       };
96685     } catch (std::exception& e) {
96686       {
96687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96688       };
96689     } catch (Dali::DaliException e) {
96690       {
96691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96692       };
96693     } catch (...) {
96694       {
96695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96696       };
96697     }
96698   }
96699
96700 }
96701
96702
96703 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3) {
96704   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96705   Dali::Actor arg2 ;
96706   bool arg3 ;
96707   Dali::Actor *argp2 ;
96708
96709   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96710   argp2 = (Dali::Actor *)jarg2;
96711   if (!argp2) {
96712     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
96713     return ;
96714   }
96715   arg2 = *argp2;
96716   arg3 = jarg3 ? true : false;
96717   {
96718     try {
96719       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3);
96720     } catch (std::out_of_range& e) {
96721       {
96722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96723       };
96724     } catch (std::exception& e) {
96725       {
96726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96727       };
96728     } catch (Dali::DaliException e) {
96729       {
96730         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96731       };
96732     } catch (...) {
96733       {
96734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96735       };
96736     }
96737   }
96738
96739 }
96740
96741
96742 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusGroupChangedSignal() {
96743   void * jresult ;
96744   Dali::Signal< void (Dali::Actor,bool) > *result = 0 ;
96745
96746   {
96747     try {
96748       result = (Dali::Signal< void (Dali::Actor,bool) > *)new Dali::Signal< void (Dali::Actor,bool) >();
96749     } catch (std::out_of_range& e) {
96750       {
96751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96752       };
96753     } catch (std::exception& e) {
96754       {
96755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96756       };
96757     } catch (Dali::DaliException e) {
96758       {
96759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96760       };
96761     } catch (...) {
96762       {
96763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96764       };
96765     }
96766   }
96767
96768   jresult = (void *)result;
96769   return jresult;
96770 }
96771
96772
96773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusGroupChangedSignal(void * jarg1) {
96774   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96775
96776   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96777   {
96778     try {
96779       delete arg1;
96780     } catch (std::out_of_range& e) {
96781       {
96782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96783       };
96784     } catch (std::exception& e) {
96785       {
96786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96787       };
96788     } catch (Dali::DaliException e) {
96789       {
96790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96791       };
96792     } catch (...) {
96793       {
96794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96795       };
96796     }
96797   }
96798
96799 }
96800
96801
96802 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Empty(void * jarg1) {
96803   unsigned int jresult ;
96804   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96805   bool result;
96806
96807   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96808   {
96809     try {
96810       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);
96811     } catch (std::out_of_range& e) {
96812       {
96813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96814       };
96815     } catch (std::exception& e) {
96816       {
96817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96818       };
96819     } catch (Dali::DaliException e) {
96820       {
96821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96822       };
96823     } catch (...) {
96824       {
96825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96826       };
96827     }
96828   }
96829
96830   jresult = result;
96831   return jresult;
96832 }
96833
96834
96835 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StyleChangedSignal_GetConnectionCount(void * jarg1) {
96836   unsigned long jresult ;
96837   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96838   std::size_t result;
96839
96840   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96841   {
96842     try {
96843       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);
96844     } catch (std::out_of_range& e) {
96845       {
96846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96847       };
96848     } catch (std::exception& e) {
96849       {
96850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96851       };
96852     } catch (Dali::DaliException e) {
96853       {
96854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96855       };
96856     } catch (...) {
96857       {
96858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96859       };
96860     }
96861   }
96862
96863   jresult = (unsigned long)result;
96864   return jresult;
96865 }
96866
96867
96868 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Connect(void * jarg1, void * jarg2) {
96869   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96870   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
96871
96872   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96873   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
96874   {
96875     try {
96876       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(arg1,arg2);
96877     } catch (std::out_of_range& e) {
96878       {
96879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96880       };
96881     } catch (std::exception& e) {
96882       {
96883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96884       };
96885     } catch (Dali::DaliException e) {
96886       {
96887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96888       };
96889     } catch (...) {
96890       {
96891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96892       };
96893     }
96894   }
96895
96896 }
96897
96898
96899 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Disconnect(void * jarg1, void * jarg2) {
96900   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96901   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
96902
96903   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96904   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
96905   {
96906     try {
96907       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(arg1,arg2);
96908     } catch (std::out_of_range& e) {
96909       {
96910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96911       };
96912     } catch (std::exception& e) {
96913       {
96914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96915       };
96916     } catch (Dali::DaliException e) {
96917       {
96918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96919       };
96920     } catch (...) {
96921       {
96922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96923       };
96924     }
96925   }
96926
96927 }
96928
96929
96930 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
96931   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96932   Dali::Toolkit::StyleManager arg2 ;
96933   Dali::StyleChange::Type arg3 ;
96934   Dali::Toolkit::StyleManager *argp2 ;
96935
96936   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96937   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
96938   if (!argp2) {
96939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
96940     return ;
96941   }
96942   arg2 = *argp2;
96943   arg3 = (Dali::StyleChange::Type)jarg3;
96944   {
96945     try {
96946       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(arg1,arg2,arg3);
96947     } catch (std::out_of_range& e) {
96948       {
96949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96950       };
96951     } catch (std::exception& e) {
96952       {
96953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96954       };
96955     } catch (Dali::DaliException e) {
96956       {
96957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96958       };
96959     } catch (...) {
96960       {
96961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96962       };
96963     }
96964   }
96965
96966 }
96967
96968
96969 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleChangedSignal() {
96970   void * jresult ;
96971   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *result = 0 ;
96972
96973   {
96974     try {
96975       result = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)new Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) >();
96976     } catch (std::out_of_range& e) {
96977       {
96978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96979       };
96980     } catch (std::exception& e) {
96981       {
96982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96983       };
96984     } catch (Dali::DaliException e) {
96985       {
96986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96987       };
96988     } catch (...) {
96989       {
96990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96991       };
96992     }
96993   }
96994
96995   jresult = (void *)result;
96996   return jresult;
96997 }
96998
96999
97000 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleChangedSignal(void * jarg1) {
97001   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
97002
97003   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
97004   {
97005     try {
97006       delete arg1;
97007     } catch (std::out_of_range& e) {
97008       {
97009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97010       };
97011     } catch (std::exception& e) {
97012       {
97013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97014       };
97015     } catch (Dali::DaliException e) {
97016       {
97017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97018       };
97019     } catch (...) {
97020       {
97021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97022       };
97023     }
97024   }
97025
97026 }
97027
97028
97029 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Empty(void * jarg1) {
97030   unsigned int jresult ;
97031   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
97032   bool result;
97033
97034   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
97035   {
97036     try {
97037       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
97038     } catch (std::out_of_range& e) {
97039       {
97040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97041       };
97042     } catch (std::exception& e) {
97043       {
97044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97045       };
97046     } catch (Dali::DaliException e) {
97047       {
97048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97049       };
97050     } catch (...) {
97051       {
97052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97053       };
97054     }
97055   }
97056
97057   jresult = result;
97058   return jresult;
97059 }
97060
97061
97062 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ButtonSignal_GetConnectionCount(void * jarg1) {
97063   unsigned long jresult ;
97064   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
97065   std::size_t result;
97066
97067   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
97068   {
97069     try {
97070       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
97071     } catch (std::out_of_range& e) {
97072       {
97073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97074       };
97075     } catch (std::exception& e) {
97076       {
97077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97078       };
97079     } catch (Dali::DaliException e) {
97080       {
97081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97082       };
97083     } catch (...) {
97084       {
97085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97086       };
97087     }
97088   }
97089
97090   jresult = (unsigned long)result;
97091   return jresult;
97092 }
97093
97094
97095 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Connect(void * jarg1, void * jarg2) {
97096   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
97097   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
97098
97099   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
97100   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
97101   {
97102     try {
97103       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(arg1,arg2);
97104     } catch (std::out_of_range& e) {
97105       {
97106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97107       };
97108     } catch (std::exception& e) {
97109       {
97110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97111       };
97112     } catch (Dali::DaliException e) {
97113       {
97114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97115       };
97116     } catch (...) {
97117       {
97118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97119       };
97120     }
97121   }
97122
97123 }
97124
97125
97126 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Disconnect(void * jarg1, void * jarg2) {
97127   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
97128   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
97129
97130   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
97131   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
97132   {
97133     try {
97134       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(arg1,arg2);
97135     } catch (std::out_of_range& e) {
97136       {
97137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97138       };
97139     } catch (std::exception& e) {
97140       {
97141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97142       };
97143     } catch (Dali::DaliException e) {
97144       {
97145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97146       };
97147     } catch (...) {
97148       {
97149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97150       };
97151     }
97152   }
97153
97154 }
97155
97156
97157 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Emit(void * jarg1, void * jarg2) {
97158   unsigned int jresult ;
97159   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
97160   Dali::Toolkit::Button arg2 ;
97161   Dali::Toolkit::Button *argp2 ;
97162   bool result;
97163
97164   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
97165   argp2 = (Dali::Toolkit::Button *)jarg2;
97166   if (!argp2) {
97167     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Button", 0);
97168     return 0;
97169   }
97170   arg2 = *argp2;
97171   {
97172     try {
97173       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(arg1,arg2);
97174     } catch (std::out_of_range& e) {
97175       {
97176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97177       };
97178     } catch (std::exception& e) {
97179       {
97180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97181       };
97182     } catch (Dali::DaliException e) {
97183       {
97184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97185       };
97186     } catch (...) {
97187       {
97188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97189       };
97190     }
97191   }
97192
97193   jresult = result;
97194   return jresult;
97195 }
97196
97197
97198 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ButtonSignal() {
97199   void * jresult ;
97200   Dali::Signal< bool (Dali::Toolkit::Button) > *result = 0 ;
97201
97202   {
97203     try {
97204       result = (Dali::Signal< bool (Dali::Toolkit::Button) > *)new Dali::Signal< bool (Dali::Toolkit::Button) >();
97205     } catch (std::out_of_range& e) {
97206       {
97207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97208       };
97209     } catch (std::exception& e) {
97210       {
97211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97212       };
97213     } catch (Dali::DaliException e) {
97214       {
97215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97216       };
97217     } catch (...) {
97218       {
97219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97220       };
97221     }
97222   }
97223
97224   jresult = (void *)result;
97225   return jresult;
97226 }
97227
97228
97229 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ButtonSignal(void * jarg1) {
97230   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
97231
97232   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
97233   {
97234     try {
97235       delete arg1;
97236     } catch (std::out_of_range& e) {
97237       {
97238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97239       };
97240     } catch (std::exception& e) {
97241       {
97242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97243       };
97244     } catch (Dali::DaliException e) {
97245       {
97246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97247       };
97248     } catch (...) {
97249       {
97250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97251       };
97252     }
97253   }
97254
97255 }
97256
97257
97258 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Empty(void * jarg1) {
97259   unsigned int jresult ;
97260   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
97261   bool result;
97262
97263   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
97264   {
97265     try {
97266       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
97267     } catch (std::out_of_range& e) {
97268       {
97269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97270       };
97271     } catch (std::exception& e) {
97272       {
97273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97274       };
97275     } catch (Dali::DaliException e) {
97276       {
97277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97278       };
97279     } catch (...) {
97280       {
97281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97282       };
97283     }
97284   }
97285
97286   jresult = result;
97287   return jresult;
97288 }
97289
97290
97291 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_GetConnectionCount(void * jarg1) {
97292   unsigned long jresult ;
97293   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
97294   std::size_t result;
97295
97296   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
97297   {
97298     try {
97299       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
97300     } catch (std::out_of_range& e) {
97301       {
97302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97303       };
97304     } catch (std::exception& e) {
97305       {
97306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97307       };
97308     } catch (Dali::DaliException e) {
97309       {
97310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97311       };
97312     } catch (...) {
97313       {
97314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97315       };
97316     }
97317   }
97318
97319   jresult = (unsigned long)result;
97320   return jresult;
97321 }
97322
97323
97324 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Connect(void * jarg1, void * jarg2) {
97325   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
97326   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
97327
97328   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
97329   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
97330   {
97331     try {
97332       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(arg1,arg2);
97333     } catch (std::out_of_range& e) {
97334       {
97335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97336       };
97337     } catch (std::exception& e) {
97338       {
97339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97340       };
97341     } catch (Dali::DaliException e) {
97342       {
97343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97344       };
97345     } catch (...) {
97346       {
97347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97348       };
97349     }
97350   }
97351
97352 }
97353
97354
97355 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Disconnect(void * jarg1, void * jarg2) {
97356   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
97357   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
97358
97359   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
97360   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
97361   {
97362     try {
97363       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(arg1,arg2);
97364     } catch (std::out_of_range& e) {
97365       {
97366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97367       };
97368     } catch (std::exception& e) {
97369       {
97370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97371       };
97372     } catch (Dali::DaliException e) {
97373       {
97374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97375       };
97376     } catch (...) {
97377       {
97378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97379       };
97380     }
97381   }
97382
97383 }
97384
97385
97386 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Emit(void * jarg1, void * jarg2) {
97387   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
97388   Dali::Toolkit::GaussianBlurView arg2 ;
97389   Dali::Toolkit::GaussianBlurView *argp2 ;
97390
97391   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
97392   argp2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
97393   if (!argp2) {
97394     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::GaussianBlurView", 0);
97395     return ;
97396   }
97397   arg2 = *argp2;
97398   {
97399     try {
97400       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(arg1,arg2);
97401     } catch (std::out_of_range& e) {
97402       {
97403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97404       };
97405     } catch (std::exception& e) {
97406       {
97407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97408       };
97409     } catch (Dali::DaliException e) {
97410       {
97411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97412       };
97413     } catch (...) {
97414       {
97415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97416       };
97417     }
97418   }
97419
97420 }
97421
97422
97423 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurViewSignal() {
97424   void * jresult ;
97425   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *result = 0 ;
97426
97427   {
97428     try {
97429       result = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)new Dali::Signal< void (Dali::Toolkit::GaussianBlurView) >();
97430     } catch (std::out_of_range& e) {
97431       {
97432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97433       };
97434     } catch (std::exception& e) {
97435       {
97436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97437       };
97438     } catch (Dali::DaliException e) {
97439       {
97440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97441       };
97442     } catch (...) {
97443       {
97444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97445       };
97446     }
97447   }
97448
97449   jresult = (void *)result;
97450   return jresult;
97451 }
97452
97453
97454 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurViewSignal(void * jarg1) {
97455   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
97456
97457   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
97458   {
97459     try {
97460       delete arg1;
97461     } catch (std::out_of_range& e) {
97462       {
97463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97464       };
97465     } catch (std::exception& e) {
97466       {
97467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97468       };
97469     } catch (Dali::DaliException e) {
97470       {
97471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97472       };
97473     } catch (...) {
97474       {
97475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97476       };
97477     }
97478   }
97479
97480 }
97481
97482
97483 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageTurnSignal_Empty(void * jarg1) {
97484   unsigned int jresult ;
97485   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
97486   bool result;
97487
97488   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
97489   {
97490     try {
97491       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);
97492     } catch (std::out_of_range& e) {
97493       {
97494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97495       };
97496     } catch (std::exception& e) {
97497       {
97498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97499       };
97500     } catch (Dali::DaliException e) {
97501       {
97502         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97503       };
97504     } catch (...) {
97505       {
97506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97507       };
97508     }
97509   }
97510
97511   jresult = result;
97512   return jresult;
97513 }
97514
97515
97516 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PageTurnSignal_GetConnectionCount(void * jarg1) {
97517   unsigned long jresult ;
97518   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
97519   std::size_t result;
97520
97521   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
97522   {
97523     try {
97524       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);
97525     } catch (std::out_of_range& e) {
97526       {
97527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97528       };
97529     } catch (std::exception& e) {
97530       {
97531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97532       };
97533     } catch (Dali::DaliException e) {
97534       {
97535         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97536       };
97537     } catch (...) {
97538       {
97539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97540       };
97541     }
97542   }
97543
97544   jresult = (unsigned long)result;
97545   return jresult;
97546 }
97547
97548
97549 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Connect(void * jarg1, void * jarg2) {
97550   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
97551   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
97552
97553   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
97554   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
97555   {
97556     try {
97557       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(arg1,arg2);
97558     } catch (std::out_of_range& e) {
97559       {
97560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97561       };
97562     } catch (std::exception& e) {
97563       {
97564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97565       };
97566     } catch (Dali::DaliException e) {
97567       {
97568         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97569       };
97570     } catch (...) {
97571       {
97572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97573       };
97574     }
97575   }
97576
97577 }
97578
97579
97580 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Disconnect(void * jarg1, void * jarg2) {
97581   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
97582   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
97583
97584   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
97585   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
97586   {
97587     try {
97588       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
97589     } catch (std::out_of_range& e) {
97590       {
97591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97592       };
97593     } catch (std::exception& e) {
97594       {
97595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97596       };
97597     } catch (Dali::DaliException e) {
97598       {
97599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97600       };
97601     } catch (...) {
97602       {
97603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97604       };
97605     }
97606   }
97607
97608 }
97609
97610
97611 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
97612   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
97613   Dali::Toolkit::PageTurnView arg2 ;
97614   unsigned int arg3 ;
97615   bool arg4 ;
97616   Dali::Toolkit::PageTurnView *argp2 ;
97617
97618   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
97619   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
97620   if (!argp2) {
97621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
97622     return ;
97623   }
97624   arg2 = *argp2;
97625   arg3 = (unsigned int)jarg3;
97626   arg4 = jarg4 ? true : false;
97627   {
97628     try {
97629       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3,arg4);
97630     } catch (std::out_of_range& e) {
97631       {
97632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97633       };
97634     } catch (std::exception& e) {
97635       {
97636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97637       };
97638     } catch (Dali::DaliException e) {
97639       {
97640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97641       };
97642     } catch (...) {
97643       {
97644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97645       };
97646     }
97647   }
97648
97649 }
97650
97651
97652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnSignal() {
97653   void * jresult ;
97654   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *result = 0 ;
97655
97656   {
97657     try {
97658       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) >();
97659     } catch (std::out_of_range& e) {
97660       {
97661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97662       };
97663     } catch (std::exception& e) {
97664       {
97665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97666       };
97667     } catch (Dali::DaliException e) {
97668       {
97669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97670       };
97671     } catch (...) {
97672       {
97673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97674       };
97675     }
97676   }
97677
97678   jresult = (void *)result;
97679   return jresult;
97680 }
97681
97682
97683 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnSignal(void * jarg1) {
97684   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
97685
97686   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
97687   {
97688     try {
97689       delete arg1;
97690     } catch (std::out_of_range& e) {
97691       {
97692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97693       };
97694     } catch (std::exception& e) {
97695       {
97696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97697       };
97698     } catch (Dali::DaliException e) {
97699       {
97700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97701       };
97702     } catch (...) {
97703       {
97704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97705       };
97706     }
97707   }
97708
97709 }
97710
97711
97712 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PagePanSignal_Empty(void * jarg1) {
97713   unsigned int jresult ;
97714   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97715   bool result;
97716
97717   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97718   {
97719     try {
97720       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
97721     } catch (std::out_of_range& e) {
97722       {
97723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97724       };
97725     } catch (std::exception& e) {
97726       {
97727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97728       };
97729     } catch (Dali::DaliException e) {
97730       {
97731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97732       };
97733     } catch (...) {
97734       {
97735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97736       };
97737     }
97738   }
97739
97740   jresult = result;
97741   return jresult;
97742 }
97743
97744
97745 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PagePanSignal_GetConnectionCount(void * jarg1) {
97746   unsigned long jresult ;
97747   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97748   std::size_t result;
97749
97750   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97751   {
97752     try {
97753       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
97754     } catch (std::out_of_range& e) {
97755       {
97756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97757       };
97758     } catch (std::exception& e) {
97759       {
97760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97761       };
97762     } catch (Dali::DaliException e) {
97763       {
97764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97765       };
97766     } catch (...) {
97767       {
97768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97769       };
97770     }
97771   }
97772
97773   jresult = (unsigned long)result;
97774   return jresult;
97775 }
97776
97777
97778 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Connect(void * jarg1, void * jarg2) {
97779   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97780   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
97781
97782   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97783   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
97784   {
97785     try {
97786       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(arg1,arg2);
97787     } catch (std::out_of_range& e) {
97788       {
97789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97790       };
97791     } catch (std::exception& e) {
97792       {
97793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97794       };
97795     } catch (Dali::DaliException e) {
97796       {
97797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97798       };
97799     } catch (...) {
97800       {
97801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97802       };
97803     }
97804   }
97805
97806 }
97807
97808
97809 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Disconnect(void * jarg1, void * jarg2) {
97810   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97811   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
97812
97813   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97814   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
97815   {
97816     try {
97817       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(arg1,arg2);
97818     } catch (std::out_of_range& e) {
97819       {
97820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97821       };
97822     } catch (std::exception& e) {
97823       {
97824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97825       };
97826     } catch (Dali::DaliException e) {
97827       {
97828         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97829       };
97830     } catch (...) {
97831       {
97832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97833       };
97834     }
97835   }
97836
97837 }
97838
97839
97840 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Emit(void * jarg1, void * jarg2) {
97841   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97842   Dali::Toolkit::PageTurnView arg2 ;
97843   Dali::Toolkit::PageTurnView *argp2 ;
97844
97845   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97846   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
97847   if (!argp2) {
97848     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
97849     return ;
97850   }
97851   arg2 = *argp2;
97852   {
97853     try {
97854       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(arg1,arg2);
97855     } catch (std::out_of_range& e) {
97856       {
97857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97858       };
97859     } catch (std::exception& e) {
97860       {
97861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97862       };
97863     } catch (Dali::DaliException e) {
97864       {
97865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97866       };
97867     } catch (...) {
97868       {
97869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97870       };
97871     }
97872   }
97873
97874 }
97875
97876
97877 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PagePanSignal() {
97878   void * jresult ;
97879   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *result = 0 ;
97880
97881   {
97882     try {
97883       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView) >();
97884     } catch (std::out_of_range& e) {
97885       {
97886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97887       };
97888     } catch (std::exception& e) {
97889       {
97890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97891       };
97892     } catch (Dali::DaliException e) {
97893       {
97894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97895       };
97896     } catch (...) {
97897       {
97898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97899       };
97900     }
97901   }
97902
97903   jresult = (void *)result;
97904   return jresult;
97905 }
97906
97907
97908 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PagePanSignal(void * jarg1) {
97909   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97910
97911   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97912   {
97913     try {
97914       delete arg1;
97915     } catch (std::out_of_range& e) {
97916       {
97917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97918       };
97919     } catch (std::exception& e) {
97920       {
97921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97922       };
97923     } catch (Dali::DaliException e) {
97924       {
97925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97926       };
97927     } catch (...) {
97928       {
97929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97930       };
97931     }
97932   }
97933
97934 }
97935
97936
97937 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Empty(void * jarg1) {
97938   unsigned int jresult ;
97939   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97940   bool result;
97941
97942   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97943   {
97944     try {
97945       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);
97946     } catch (std::out_of_range& e) {
97947       {
97948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97949       };
97950     } catch (std::exception& e) {
97951       {
97952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97953       };
97954     } catch (Dali::DaliException e) {
97955       {
97956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97957       };
97958     } catch (...) {
97959       {
97960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97961       };
97962     }
97963   }
97964
97965   jresult = result;
97966   return jresult;
97967 }
97968
97969
97970 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_GetConnectionCount(void * jarg1) {
97971   unsigned long jresult ;
97972   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97973   std::size_t result;
97974
97975   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97976   {
97977     try {
97978       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);
97979     } catch (std::out_of_range& e) {
97980       {
97981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97982       };
97983     } catch (std::exception& e) {
97984       {
97985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97986       };
97987     } catch (Dali::DaliException e) {
97988       {
97989         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97990       };
97991     } catch (...) {
97992       {
97993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97994       };
97995     }
97996   }
97997
97998   jresult = (unsigned long)result;
97999   return jresult;
98000 }
98001
98002
98003 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Connect(void * jarg1, void * jarg2) {
98004   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
98005   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
98006
98007   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
98008   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
98009   {
98010     try {
98011       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(arg1,arg2);
98012     } catch (std::out_of_range& e) {
98013       {
98014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98015       };
98016     } catch (std::exception& e) {
98017       {
98018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98019       };
98020     } catch (Dali::DaliException e) {
98021       {
98022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98023       };
98024     } catch (...) {
98025       {
98026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98027       };
98028     }
98029   }
98030
98031 }
98032
98033
98034 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
98035   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
98036   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
98037
98038   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
98039   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
98040   {
98041     try {
98042       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(arg1,arg2);
98043     } catch (std::out_of_range& e) {
98044       {
98045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98046       };
98047     } catch (std::exception& e) {
98048       {
98049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98050       };
98051     } catch (Dali::DaliException e) {
98052       {
98053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98054       };
98055     } catch (...) {
98056       {
98057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98058       };
98059     }
98060   }
98061
98062 }
98063
98064
98065 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3, float jarg4) {
98066   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
98067   Dali::Toolkit::ProgressBar arg2 ;
98068   float arg3 ;
98069   float arg4 ;
98070   Dali::Toolkit::ProgressBar *argp2 ;
98071
98072   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
98073   argp2 = (Dali::Toolkit::ProgressBar *)jarg2;
98074   if (!argp2) {
98075     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ProgressBar", 0);
98076     return ;
98077   }
98078   arg2 = *argp2;
98079   arg3 = (float)jarg3;
98080   arg4 = (float)jarg4;
98081   {
98082     try {
98083       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(arg1,arg2,arg3,arg4);
98084     } catch (std::out_of_range& e) {
98085       {
98086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98087       };
98088     } catch (std::exception& e) {
98089       {
98090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98091       };
98092     } catch (Dali::DaliException e) {
98093       {
98094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98095       };
98096     } catch (...) {
98097       {
98098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98099       };
98100     }
98101   }
98102
98103 }
98104
98105
98106 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBarValueChangedSignal() {
98107   void * jresult ;
98108   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *result = 0 ;
98109
98110   {
98111     try {
98112       result = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)new Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) >();
98113     } catch (std::out_of_range& e) {
98114       {
98115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98116       };
98117     } catch (std::exception& e) {
98118       {
98119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98120       };
98121     } catch (Dali::DaliException e) {
98122       {
98123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98124       };
98125     } catch (...) {
98126       {
98127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98128       };
98129     }
98130   }
98131
98132   jresult = (void *)result;
98133   return jresult;
98134 }
98135
98136
98137 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBarValueChangedSignal(void * jarg1) {
98138   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
98139
98140   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
98141   {
98142     try {
98143       delete arg1;
98144     } catch (std::out_of_range& e) {
98145       {
98146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98147       };
98148     } catch (std::exception& e) {
98149       {
98150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98151       };
98152     } catch (Dali::DaliException e) {
98153       {
98154         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98155       };
98156     } catch (...) {
98157       {
98158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98159       };
98160     }
98161   }
98162
98163 }
98164
98165
98166 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Empty(void * jarg1) {
98167   unsigned int jresult ;
98168   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
98169   bool result;
98170
98171   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
98172   {
98173     try {
98174       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);
98175     } catch (std::out_of_range& e) {
98176       {
98177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98178       };
98179     } catch (std::exception& e) {
98180       {
98181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98182       };
98183     } catch (Dali::DaliException e) {
98184       {
98185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98186       };
98187     } catch (...) {
98188       {
98189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98190       };
98191     }
98192   }
98193
98194   jresult = result;
98195   return jresult;
98196 }
98197
98198
98199 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_GetConnectionCount(void * jarg1) {
98200   unsigned long jresult ;
98201   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
98202   std::size_t result;
98203
98204   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
98205   {
98206     try {
98207       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);
98208     } catch (std::out_of_range& e) {
98209       {
98210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98211       };
98212     } catch (std::exception& e) {
98213       {
98214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98215       };
98216     } catch (Dali::DaliException e) {
98217       {
98218         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98219       };
98220     } catch (...) {
98221       {
98222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98223       };
98224     }
98225   }
98226
98227   jresult = (unsigned long)result;
98228   return jresult;
98229 }
98230
98231
98232 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Connect(void * jarg1, void * jarg2) {
98233   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
98234   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
98235
98236   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
98237   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
98238   {
98239     try {
98240       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
98241     } catch (std::out_of_range& e) {
98242       {
98243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98244       };
98245     } catch (std::exception& e) {
98246       {
98247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98248       };
98249     } catch (Dali::DaliException e) {
98250       {
98251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98252       };
98253     } catch (...) {
98254       {
98255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98256       };
98257     }
98258   }
98259
98260 }
98261
98262
98263 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Disconnect(void * jarg1, void * jarg2) {
98264   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
98265   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
98266
98267   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
98268   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
98269   {
98270     try {
98271       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
98272     } catch (std::out_of_range& e) {
98273       {
98274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98275       };
98276     } catch (std::exception& e) {
98277       {
98278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98279       };
98280     } catch (Dali::DaliException e) {
98281       {
98282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98283       };
98284     } catch (...) {
98285       {
98286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98287       };
98288     }
98289   }
98290
98291 }
98292
98293
98294 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Emit(void * jarg1, void * jarg2) {
98295   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
98296   Dali::Toolkit::ScrollView::SnapEvent *arg2 = 0 ;
98297
98298   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
98299   arg2 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg2;
98300   if (!arg2) {
98301     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView::SnapEvent const & type is null", 0);
98302     return ;
98303   }
98304   {
98305     try {
98306       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Toolkit::ScrollView::SnapEvent const &)*arg2);
98307     } catch (std::out_of_range& e) {
98308       {
98309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98310       };
98311     } catch (std::exception& e) {
98312       {
98313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98314       };
98315     } catch (Dali::DaliException e) {
98316       {
98317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98318       };
98319     } catch (...) {
98320       {
98321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98322       };
98323     }
98324   }
98325
98326 }
98327
98328
98329 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewSnapStartedSignal() {
98330   void * jresult ;
98331   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *result = 0 ;
98332
98333   {
98334     try {
98335       result = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)new Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) >();
98336     } catch (std::out_of_range& e) {
98337       {
98338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98339       };
98340     } catch (std::exception& e) {
98341       {
98342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98343       };
98344     } catch (Dali::DaliException e) {
98345       {
98346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98347       };
98348     } catch (...) {
98349       {
98350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98351       };
98352     }
98353   }
98354
98355   jresult = (void *)result;
98356   return jresult;
98357 }
98358
98359
98360 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewSnapStartedSignal(void * jarg1) {
98361   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
98362
98363   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
98364   {
98365     try {
98366       delete arg1;
98367     } catch (std::out_of_range& e) {
98368       {
98369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98370       };
98371     } catch (std::exception& e) {
98372       {
98373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98374       };
98375     } catch (Dali::DaliException e) {
98376       {
98377         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98378       };
98379     } catch (...) {
98380       {
98381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98382       };
98383     }
98384   }
98385
98386 }
98387
98388
98389 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollableSignal_Empty(void * jarg1) {
98390   unsigned int jresult ;
98391   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
98392   bool result;
98393
98394   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
98395   {
98396     try {
98397       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
98398     } catch (std::out_of_range& e) {
98399       {
98400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98401       };
98402     } catch (std::exception& e) {
98403       {
98404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98405       };
98406     } catch (Dali::DaliException e) {
98407       {
98408         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98409       };
98410     } catch (...) {
98411       {
98412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98413       };
98414     }
98415   }
98416
98417   jresult = result;
98418   return jresult;
98419 }
98420
98421
98422 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollableSignal_GetConnectionCount(void * jarg1) {
98423   unsigned long jresult ;
98424   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
98425   std::size_t result;
98426
98427   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
98428   {
98429     try {
98430       result = Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
98431     } catch (std::out_of_range& e) {
98432       {
98433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98434       };
98435     } catch (std::exception& e) {
98436       {
98437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98438       };
98439     } catch (Dali::DaliException e) {
98440       {
98441         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98442       };
98443     } catch (...) {
98444       {
98445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98446       };
98447     }
98448   }
98449
98450   jresult = (unsigned long)result;
98451   return jresult;
98452 }
98453
98454
98455 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Connect(void * jarg1, void * jarg2) {
98456   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
98457   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
98458
98459   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
98460   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
98461   {
98462     try {
98463       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(arg1,arg2);
98464     } catch (std::out_of_range& e) {
98465       {
98466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98467       };
98468     } catch (std::exception& e) {
98469       {
98470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98471       };
98472     } catch (Dali::DaliException e) {
98473       {
98474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98475       };
98476     } catch (...) {
98477       {
98478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98479       };
98480     }
98481   }
98482
98483 }
98484
98485
98486 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Disconnect(void * jarg1, void * jarg2) {
98487   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
98488   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
98489
98490   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
98491   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
98492   {
98493     try {
98494       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
98495     } catch (std::out_of_range& e) {
98496       {
98497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98498       };
98499     } catch (std::exception& e) {
98500       {
98501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98502       };
98503     } catch (Dali::DaliException e) {
98504       {
98505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98506       };
98507     } catch (...) {
98508       {
98509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98510       };
98511     }
98512   }
98513
98514 }
98515
98516
98517 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Emit(void * jarg1, void * jarg2) {
98518   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
98519   Dali::Vector2 *arg2 = 0 ;
98520
98521   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
98522   arg2 = (Dali::Vector2 *)jarg2;
98523   if (!arg2) {
98524     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
98525     return ;
98526   }
98527   {
98528     try {
98529       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Vector2 const &)*arg2);
98530     } catch (std::out_of_range& e) {
98531       {
98532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98533       };
98534     } catch (std::exception& e) {
98535       {
98536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98537       };
98538     } catch (Dali::DaliException e) {
98539       {
98540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98541       };
98542     } catch (...) {
98543       {
98544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98545       };
98546     }
98547   }
98548
98549 }
98550
98551
98552 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollableSignal() {
98553   void * jresult ;
98554   Dali::Signal< void (Dali::Vector2 const &) > *result = 0 ;
98555
98556   {
98557     try {
98558       result = (Dali::Signal< void (Dali::Vector2 const &) > *)new Dali::Signal< void (Dali::Vector2 const &) >();
98559     } catch (std::out_of_range& e) {
98560       {
98561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98562       };
98563     } catch (std::exception& e) {
98564       {
98565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98566       };
98567     } catch (Dali::DaliException e) {
98568       {
98569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98570       };
98571     } catch (...) {
98572       {
98573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98574       };
98575     }
98576   }
98577
98578   jresult = (void *)result;
98579   return jresult;
98580 }
98581
98582
98583 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollableSignal(void * jarg1) {
98584   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
98585
98586   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
98587   {
98588     try {
98589       delete arg1;
98590     } catch (std::out_of_range& e) {
98591       {
98592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98593       };
98594     } catch (std::exception& e) {
98595       {
98596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98597       };
98598     } catch (Dali::DaliException e) {
98599       {
98600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98601       };
98602     } catch (...) {
98603       {
98604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98605       };
98606     }
98607   }
98608
98609 }
98610
98611
98612
98613 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Empty(void * jarg1) {
98614   unsigned int jresult ;
98615   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98616   bool result;
98617
98618   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98619   {
98620     try {
98621       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);
98622     } catch (std::out_of_range& e) {
98623       {
98624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98625       };
98626     } catch (std::exception& e) {
98627       {
98628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98629       };
98630     } catch (Dali::DaliException e) {
98631       {
98632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98633       };
98634     } catch (...) {
98635       {
98636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98637       };
98638     }
98639   }
98640
98641   jresult = result;
98642   return jresult;
98643 }
98644
98645
98646 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ControlKeySignal_GetConnectionCount(void * jarg1) {
98647   unsigned long jresult ;
98648   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98649   std::size_t result;
98650
98651   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98652   {
98653     try {
98654       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);
98655     } catch (std::out_of_range& e) {
98656       {
98657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98658       };
98659     } catch (std::exception& e) {
98660       {
98661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98662       };
98663     } catch (Dali::DaliException e) {
98664       {
98665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98666       };
98667     } catch (...) {
98668       {
98669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98670       };
98671     }
98672   }
98673
98674   jresult = (unsigned long)result;
98675   return jresult;
98676 }
98677
98678
98679 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Connect(void * jarg1, void * jarg2) {
98680   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98681   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
98682
98683   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98684   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
98685   {
98686     try {
98687       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
98688     } catch (std::out_of_range& e) {
98689       {
98690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98691       };
98692     } catch (std::exception& e) {
98693       {
98694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98695       };
98696     } catch (Dali::DaliException e) {
98697       {
98698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98699       };
98700     } catch (...) {
98701       {
98702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98703       };
98704     }
98705   }
98706
98707 }
98708
98709
98710 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Disconnect(void * jarg1, void * jarg2) {
98711   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98712   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
98713
98714   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98715   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
98716   {
98717     try {
98718       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
98719     } catch (std::out_of_range& e) {
98720       {
98721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98722       };
98723     } catch (std::exception& e) {
98724       {
98725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98726       };
98727     } catch (Dali::DaliException e) {
98728       {
98729         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98730       };
98731     } catch (...) {
98732       {
98733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98734       };
98735     }
98736   }
98737
98738 }
98739
98740
98741 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
98742   unsigned int jresult ;
98743   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98744   Dali::Toolkit::Control arg2 ;
98745   Dali::KeyEvent *arg3 = 0 ;
98746   Dali::Toolkit::Control *argp2 ;
98747   bool result;
98748
98749   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98750   argp2 = (Dali::Toolkit::Control *)jarg2;
98751   if (!argp2) {
98752     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
98753     return 0;
98754   }
98755   arg2 = *argp2;
98756   arg3 = (Dali::KeyEvent *)jarg3;
98757   if (!arg3) {
98758     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
98759     return 0;
98760   }
98761   {
98762     try {
98763       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);
98764     } catch (std::out_of_range& e) {
98765       {
98766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98767       };
98768     } catch (std::exception& e) {
98769       {
98770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98771       };
98772     } catch (Dali::DaliException e) {
98773       {
98774         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98775       };
98776     } catch (...) {
98777       {
98778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98779       };
98780     }
98781   }
98782
98783   jresult = result;
98784   return jresult;
98785 }
98786
98787
98788 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ControlKeySignal() {
98789   void * jresult ;
98790   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *result = 0 ;
98791
98792   {
98793     try {
98794       result = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)new Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) >();
98795     } catch (std::out_of_range& e) {
98796       {
98797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98798       };
98799     } catch (std::exception& e) {
98800       {
98801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98802       };
98803     } catch (Dali::DaliException e) {
98804       {
98805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98806       };
98807     } catch (...) {
98808       {
98809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98810       };
98811     }
98812   }
98813
98814   jresult = (void *)result;
98815   return jresult;
98816 }
98817
98818
98819 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ControlKeySignal(void * jarg1) {
98820   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98821
98822   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98823   {
98824     try {
98825       delete arg1;
98826     } catch (std::out_of_range& e) {
98827       {
98828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98829       };
98830     } catch (std::exception& e) {
98831       {
98832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98833       };
98834     } catch (Dali::DaliException e) {
98835       {
98836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98837       };
98838     } catch (...) {
98839       {
98840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98841       };
98842     }
98843   }
98844
98845 }
98846
98847
98848 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Empty(void * jarg1) {
98849   unsigned int jresult ;
98850   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98851   bool result;
98852
98853   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98854   {
98855     try {
98856       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
98857     } catch (std::out_of_range& e) {
98858       {
98859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98860       };
98861     } catch (std::exception& e) {
98862       {
98863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98864       };
98865     } catch (Dali::DaliException e) {
98866       {
98867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98868       };
98869     } catch (...) {
98870       {
98871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98872       };
98873     }
98874   }
98875
98876   jresult = result;
98877   return jresult;
98878 }
98879
98880
98881 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_GetConnectionCount(void * jarg1) {
98882   unsigned long jresult ;
98883   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98884   std::size_t result;
98885
98886   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98887   {
98888     try {
98889       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
98890     } catch (std::out_of_range& e) {
98891       {
98892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98893       };
98894     } catch (std::exception& e) {
98895       {
98896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98897       };
98898     } catch (Dali::DaliException e) {
98899       {
98900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98901       };
98902     } catch (...) {
98903       {
98904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98905       };
98906     }
98907   }
98908
98909   jresult = (unsigned long)result;
98910   return jresult;
98911 }
98912
98913
98914 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Connect(void * jarg1, void * jarg2) {
98915   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98916   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
98917
98918   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98919   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
98920   {
98921     try {
98922       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
98923     } catch (std::out_of_range& e) {
98924       {
98925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98926       };
98927     } catch (std::exception& e) {
98928       {
98929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98930       };
98931     } catch (Dali::DaliException e) {
98932       {
98933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98934       };
98935     } catch (...) {
98936       {
98937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98938       };
98939     }
98940   }
98941
98942 }
98943
98944
98945 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Disconnect(void * jarg1, void * jarg2) {
98946   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98947   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
98948
98949   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98950   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
98951   {
98952     try {
98953       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
98954     } catch (std::out_of_range& e) {
98955       {
98956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98957       };
98958     } catch (std::exception& e) {
98959       {
98960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98961       };
98962     } catch (Dali::DaliException e) {
98963       {
98964         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98965       };
98966     } catch (...) {
98967       {
98968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98969       };
98970     }
98971   }
98972
98973 }
98974
98975
98976 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Emit(void * jarg1, void * jarg2) {
98977   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98978   Dali::Toolkit::Control arg2 ;
98979   Dali::Toolkit::Control *argp2 ;
98980
98981   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98982   argp2 = (Dali::Toolkit::Control *)jarg2;
98983   if (!argp2) {
98984     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
98985     return ;
98986   }
98987   arg2 = *argp2;
98988   {
98989     try {
98990       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
98991     } catch (std::out_of_range& e) {
98992       {
98993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98994       };
98995     } catch (std::exception& e) {
98996       {
98997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98998       };
98999     } catch (Dali::DaliException e) {
99000       {
99001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99002       };
99003     } catch (...) {
99004       {
99005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99006       };
99007     }
99008   }
99009
99010 }
99011
99012
99013 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusSignal() {
99014   void * jresult ;
99015   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
99016
99017   {
99018     try {
99019       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
99020     } catch (std::out_of_range& e) {
99021       {
99022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99023       };
99024     } catch (std::exception& e) {
99025       {
99026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99027       };
99028     } catch (Dali::DaliException e) {
99029       {
99030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99031       };
99032     } catch (...) {
99033       {
99034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99035       };
99036     }
99037   }
99038
99039   jresult = (void *)result;
99040   return jresult;
99041 }
99042
99043
99044 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusSignal(void * jarg1) {
99045   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
99046
99047   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
99048   {
99049     try {
99050       delete arg1;
99051     } catch (std::out_of_range& e) {
99052       {
99053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99054       };
99055     } catch (std::exception& e) {
99056       {
99057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99058       };
99059     } catch (Dali::DaliException e) {
99060       {
99061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99062       };
99063     } catch (...) {
99064       {
99065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99066       };
99067     }
99068   }
99069
99070 }
99071
99072
99073 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VideoViewSignal_Empty(void * jarg1) {
99074   unsigned int jresult ;
99075   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
99076   bool result;
99077
99078   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
99079   {
99080     try {
99081       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
99082     } catch (std::out_of_range& e) {
99083       {
99084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99085       };
99086     } catch (std::exception& e) {
99087       {
99088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99089       };
99090     } catch (Dali::DaliException e) {
99091       {
99092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99093       };
99094     } catch (...) {
99095       {
99096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99097       };
99098     }
99099   }
99100
99101   jresult = result;
99102   return jresult;
99103 }
99104
99105
99106 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VideoViewSignal_GetConnectionCount(void * jarg1) {
99107   unsigned long jresult ;
99108   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
99109   std::size_t result;
99110
99111   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
99112   {
99113     try {
99114       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
99115     } catch (std::out_of_range& e) {
99116       {
99117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99118       };
99119     } catch (std::exception& e) {
99120       {
99121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99122       };
99123     } catch (Dali::DaliException e) {
99124       {
99125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99126       };
99127     } catch (...) {
99128       {
99129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99130       };
99131     }
99132   }
99133
99134   jresult = (unsigned long)result;
99135   return jresult;
99136 }
99137
99138
99139 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Connect(void * jarg1, void * jarg2) {
99140   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
99141   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
99142
99143   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
99144   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
99145   {
99146     try {
99147       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(arg1,arg2);
99148     } catch (std::out_of_range& e) {
99149       {
99150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99151       };
99152     } catch (std::exception& e) {
99153       {
99154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99155       };
99156     } catch (Dali::DaliException e) {
99157       {
99158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99159       };
99160     } catch (...) {
99161       {
99162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99163       };
99164     }
99165   }
99166
99167 }
99168
99169
99170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Disconnect(void * jarg1, void * jarg2) {
99171   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
99172   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
99173
99174   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
99175   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
99176   {
99177     try {
99178       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(arg1,arg2);
99179     } catch (std::out_of_range& e) {
99180       {
99181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99182       };
99183     } catch (std::exception& e) {
99184       {
99185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99186       };
99187     } catch (Dali::DaliException e) {
99188       {
99189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99190       };
99191     } catch (...) {
99192       {
99193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99194       };
99195     }
99196   }
99197
99198 }
99199
99200
99201 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Emit(void * jarg1, void * jarg2) {
99202   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
99203   Dali::Toolkit::VideoView *arg2 = 0 ;
99204
99205   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
99206   arg2 = (Dali::Toolkit::VideoView *)jarg2;
99207   if (!arg2) {
99208     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView & type is null", 0);
99209     return ;
99210   }
99211   {
99212     try {
99213       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(arg1,*arg2);
99214     } catch (std::out_of_range& e) {
99215       {
99216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99217       };
99218     } catch (std::exception& e) {
99219       {
99220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99221       };
99222     } catch (Dali::DaliException e) {
99223       {
99224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99225       };
99226     } catch (...) {
99227       {
99228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99229       };
99230     }
99231   }
99232
99233 }
99234
99235
99236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoViewSignal() {
99237   void * jresult ;
99238   Dali::Signal< void (Dali::Toolkit::VideoView &) > *result = 0 ;
99239
99240   {
99241     try {
99242       result = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)new Dali::Signal< void (Dali::Toolkit::VideoView &) >();
99243     } catch (std::out_of_range& e) {
99244       {
99245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99246       };
99247     } catch (std::exception& e) {
99248       {
99249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99250       };
99251     } catch (Dali::DaliException e) {
99252       {
99253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99254       };
99255     } catch (...) {
99256       {
99257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99258       };
99259     }
99260   }
99261
99262   jresult = (void *)result;
99263   return jresult;
99264 }
99265
99266
99267 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoViewSignal(void * jarg1) {
99268   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
99269
99270   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
99271   {
99272     try {
99273       delete arg1;
99274     } catch (std::out_of_range& e) {
99275       {
99276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99277       };
99278     } catch (std::exception& e) {
99279       {
99280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99281       };
99282     } catch (Dali::DaliException e) {
99283       {
99284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99285       };
99286     } catch (...) {
99287       {
99288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99289       };
99290     }
99291   }
99292
99293 }
99294
99295
99296 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Empty(void * jarg1) {
99297   unsigned int jresult ;
99298   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
99299   bool result;
99300
99301   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
99302   {
99303     try {
99304       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
99305     } catch (std::out_of_range& e) {
99306       {
99307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99308       };
99309     } catch (std::exception& e) {
99310       {
99311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99312       };
99313     } catch (Dali::DaliException e) {
99314       {
99315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99316       };
99317     } catch (...) {
99318       {
99319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99320       };
99321     }
99322   }
99323
99324   jresult = result;
99325   return jresult;
99326 }
99327
99328
99329 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_GetConnectionCount(void * jarg1) {
99330   unsigned long jresult ;
99331   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
99332   std::size_t result;
99333
99334   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
99335   {
99336     try {
99337       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
99338     } catch (std::out_of_range& e) {
99339       {
99340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99341       };
99342     } catch (std::exception& e) {
99343       {
99344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99345       };
99346     } catch (Dali::DaliException e) {
99347       {
99348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99349       };
99350     } catch (...) {
99351       {
99352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99353       };
99354     }
99355   }
99356
99357   jresult = (unsigned long)result;
99358   return jresult;
99359 }
99360
99361
99362 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Connect(void * jarg1, void * jarg2) {
99363   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
99364   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
99365
99366   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
99367   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
99368   {
99369     try {
99370       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(arg1,arg2);
99371     } catch (std::out_of_range& e) {
99372       {
99373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99374       };
99375     } catch (std::exception& e) {
99376       {
99377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99378       };
99379     } catch (Dali::DaliException e) {
99380       {
99381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99382       };
99383     } catch (...) {
99384       {
99385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99386       };
99387     }
99388   }
99389
99390 }
99391
99392
99393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
99394   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
99395   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
99396
99397   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
99398   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
99399   {
99400     try {
99401       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(arg1,arg2);
99402     } catch (std::out_of_range& e) {
99403       {
99404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99405       };
99406     } catch (std::exception& e) {
99407       {
99408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99409       };
99410     } catch (Dali::DaliException e) {
99411       {
99412         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99413       };
99414     } catch (...) {
99415       {
99416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99417       };
99418     }
99419   }
99420
99421 }
99422
99423
99424 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3) {
99425   unsigned int jresult ;
99426   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
99427   Dali::Toolkit::Slider arg2 ;
99428   float arg3 ;
99429   Dali::Toolkit::Slider *argp2 ;
99430   bool result;
99431
99432   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
99433   argp2 = (Dali::Toolkit::Slider *)jarg2;
99434   if (!argp2) {
99435     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
99436     return 0;
99437   }
99438   arg2 = *argp2;
99439   arg3 = (float)jarg3;
99440   {
99441     try {
99442       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(arg1,arg2,arg3);
99443     } catch (std::out_of_range& e) {
99444       {
99445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99446       };
99447     } catch (std::exception& e) {
99448       {
99449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99450       };
99451     } catch (Dali::DaliException e) {
99452       {
99453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99454       };
99455     } catch (...) {
99456       {
99457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99458       };
99459     }
99460   }
99461
99462   jresult = result;
99463   return jresult;
99464 }
99465
99466
99467 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderValueChangedSignal() {
99468   void * jresult ;
99469   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *result = 0 ;
99470
99471   {
99472     try {
99473       result = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,float) >();
99474     } catch (std::out_of_range& e) {
99475       {
99476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99477       };
99478     } catch (std::exception& e) {
99479       {
99480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99481       };
99482     } catch (Dali::DaliException e) {
99483       {
99484         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99485       };
99486     } catch (...) {
99487       {
99488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99489       };
99490     }
99491   }
99492
99493   jresult = (void *)result;
99494   return jresult;
99495 }
99496
99497
99498 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderValueChangedSignal(void * jarg1) {
99499   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
99500
99501   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
99502   {
99503     try {
99504       delete arg1;
99505     } catch (std::out_of_range& e) {
99506       {
99507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99508       };
99509     } catch (std::exception& e) {
99510       {
99511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99512       };
99513     } catch (Dali::DaliException e) {
99514       {
99515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99516       };
99517     } catch (...) {
99518       {
99519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99520       };
99521     }
99522   }
99523
99524 }
99525
99526
99527 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Empty(void * jarg1) {
99528   unsigned int jresult ;
99529   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99530   bool result;
99531
99532   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99533   {
99534     try {
99535       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
99536     } catch (std::out_of_range& e) {
99537       {
99538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99539       };
99540     } catch (std::exception& e) {
99541       {
99542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99543       };
99544     } catch (Dali::DaliException e) {
99545       {
99546         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99547       };
99548     } catch (...) {
99549       {
99550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99551       };
99552     }
99553   }
99554
99555   jresult = result;
99556   return jresult;
99557 }
99558
99559
99560 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_GetConnectionCount(void * jarg1) {
99561   unsigned long jresult ;
99562   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99563   std::size_t result;
99564
99565   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99566   {
99567     try {
99568       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
99569     } catch (std::out_of_range& e) {
99570       {
99571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99572       };
99573     } catch (std::exception& e) {
99574       {
99575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99576       };
99577     } catch (Dali::DaliException e) {
99578       {
99579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99580       };
99581     } catch (...) {
99582       {
99583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99584       };
99585     }
99586   }
99587
99588   jresult = (unsigned long)result;
99589   return jresult;
99590 }
99591
99592
99593 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Connect(void * jarg1, void * jarg2) {
99594   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99595   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
99596
99597   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99598   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
99599   {
99600     try {
99601       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(arg1,arg2);
99602     } catch (std::out_of_range& e) {
99603       {
99604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99605       };
99606     } catch (std::exception& e) {
99607       {
99608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99609       };
99610     } catch (Dali::DaliException e) {
99611       {
99612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99613       };
99614     } catch (...) {
99615       {
99616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99617       };
99618     }
99619   }
99620
99621 }
99622
99623
99624 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Disconnect(void * jarg1, void * jarg2) {
99625   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99626   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
99627
99628   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99629   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
99630   {
99631     try {
99632       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(arg1,arg2);
99633     } catch (std::out_of_range& e) {
99634       {
99635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99636       };
99637     } catch (std::exception& e) {
99638       {
99639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99640       };
99641     } catch (Dali::DaliException e) {
99642       {
99643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99644       };
99645     } catch (...) {
99646       {
99647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99648       };
99649     }
99650   }
99651
99652 }
99653
99654
99655 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
99656   unsigned int jresult ;
99657   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99658   Dali::Toolkit::Slider arg2 ;
99659   int arg3 ;
99660   Dali::Toolkit::Slider *argp2 ;
99661   bool result;
99662
99663   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99664   argp2 = (Dali::Toolkit::Slider *)jarg2;
99665   if (!argp2) {
99666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
99667     return 0;
99668   }
99669   arg2 = *argp2;
99670   arg3 = (int)jarg3;
99671   {
99672     try {
99673       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(arg1,arg2,arg3);
99674     } catch (std::out_of_range& e) {
99675       {
99676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99677       };
99678     } catch (std::exception& e) {
99679       {
99680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99681       };
99682     } catch (Dali::DaliException e) {
99683       {
99684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99685       };
99686     } catch (...) {
99687       {
99688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99689       };
99690     }
99691   }
99692
99693   jresult = result;
99694   return jresult;
99695 }
99696
99697
99698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderMarkReachedSignal() {
99699   void * jresult ;
99700   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *result = 0 ;
99701
99702   {
99703     try {
99704       result = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,int) >();
99705     } catch (std::out_of_range& e) {
99706       {
99707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99708       };
99709     } catch (std::exception& e) {
99710       {
99711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99712       };
99713     } catch (Dali::DaliException e) {
99714       {
99715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99716       };
99717     } catch (...) {
99718       {
99719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99720       };
99721     }
99722   }
99723
99724   jresult = (void *)result;
99725   return jresult;
99726 }
99727
99728
99729 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderMarkReachedSignal(void * jarg1) {
99730   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99731
99732   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99733   {
99734     try {
99735       delete arg1;
99736     } catch (std::out_of_range& e) {
99737       {
99738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99739       };
99740     } catch (std::exception& e) {
99741       {
99742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99743       };
99744     } catch (Dali::DaliException e) {
99745       {
99746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99747       };
99748     } catch (...) {
99749       {
99750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99751       };
99752     }
99753   }
99754
99755 }
99756
99757
99758 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_0() {
99759   void * jresult ;
99760   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99761
99762   {
99763     try {
99764       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >();
99765     } catch (std::out_of_range& e) {
99766       {
99767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99768       };
99769     } catch (std::exception& e) {
99770       {
99771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99772       };
99773     } catch (Dali::DaliException e) {
99774       {
99775         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99776       };
99777     } catch (...) {
99778       {
99779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99780       };
99781     }
99782   }
99783
99784   jresult = (void *)result;
99785   return jresult;
99786 }
99787
99788
99789 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_1(void * jarg1) {
99790   void * jresult ;
99791   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
99792   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99793
99794   arg1 = (Dali::Toolkit::Ruler *)jarg1;
99795   {
99796     try {
99797       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >(arg1);
99798     } catch (std::out_of_range& e) {
99799       {
99800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99801       };
99802     } catch (std::exception& e) {
99803       {
99804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99805       };
99806     } catch (Dali::DaliException e) {
99807       {
99808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99809       };
99810     } catch (...) {
99811       {
99812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99813       };
99814     }
99815   }
99816
99817   jresult = (void *)result;
99818   return jresult;
99819 }
99820
99821
99822 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_2(void * jarg1) {
99823   void * jresult ;
99824   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = 0 ;
99825   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99826
99827   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99828   if (!arg1) {
99829     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
99830     return 0;
99831   }
99832   {
99833     try {
99834       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg1);
99835     } catch (std::out_of_range& e) {
99836       {
99837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99838       };
99839     } catch (std::exception& e) {
99840       {
99841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99842       };
99843     } catch (Dali::DaliException e) {
99844       {
99845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99846       };
99847     } catch (...) {
99848       {
99849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99850       };
99851     }
99852   }
99853
99854   jresult = (void *)result;
99855   return jresult;
99856 }
99857
99858
99859 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerPtr(void * jarg1) {
99860   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99861
99862   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99863   {
99864     try {
99865       delete arg1;
99866     } catch (std::out_of_range& e) {
99867       {
99868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99869       };
99870     } catch (std::exception& e) {
99871       {
99872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99873       };
99874     } catch (Dali::DaliException e) {
99875       {
99876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99877       };
99878     } catch (...) {
99879       {
99880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99881       };
99882     }
99883   }
99884
99885 }
99886
99887
99888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Get(void * jarg1) {
99889   void * jresult ;
99890   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99891   Dali::Toolkit::Ruler *result = 0 ;
99892
99893   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99894   {
99895     try {
99896       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->Get();
99897     } catch (std::out_of_range& e) {
99898       {
99899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99900       };
99901     } catch (std::exception& e) {
99902       {
99903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99904       };
99905     } catch (Dali::DaliException e) {
99906       {
99907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99908       };
99909     } catch (...) {
99910       {
99911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99912       };
99913     }
99914   }
99915
99916   jresult = (void *)result;
99917   return jresult;
99918 }
99919
99920
99921 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___deref__(void * jarg1) {
99922   void * jresult ;
99923   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99924   Dali::Toolkit::Ruler *result = 0 ;
99925
99926   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99927   {
99928     try {
99929       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator ->();
99930     } catch (std::out_of_range& e) {
99931       {
99932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99933       };
99934     } catch (std::exception& e) {
99935       {
99936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99937       };
99938     } catch (Dali::DaliException e) {
99939       {
99940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99941       };
99942     } catch (...) {
99943       {
99944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99945       };
99946     }
99947   }
99948
99949   jresult = (void *)result;
99950   return jresult;
99951 }
99952
99953
99954 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___ref__(void * jarg1) {
99955   void * jresult ;
99956   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99957   Dali::Toolkit::Ruler *result = 0 ;
99958
99959   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99960   {
99961     try {
99962       result = (Dali::Toolkit::Ruler *) &((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator *();
99963     } catch (std::out_of_range& e) {
99964       {
99965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99966       };
99967     } catch (std::exception& e) {
99968       {
99969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99970       };
99971     } catch (Dali::DaliException e) {
99972       {
99973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99974       };
99975     } catch (...) {
99976       {
99977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99978       };
99979     }
99980   }
99981
99982   jresult = (void *)result;
99983   return jresult;
99984 }
99985
99986
99987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_0(void * jarg1, void * jarg2) {
99988   void * jresult ;
99989   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99990   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg2 = 0 ;
99991   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99992
99993   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99994   arg2 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg2;
99995   if (!arg2) {
99996     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
99997     return 0;
99998   }
99999   {
100000     try {
100001       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg2);
100002     } catch (std::out_of_range& e) {
100003       {
100004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100005       };
100006     } catch (std::exception& e) {
100007       {
100008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100009       };
100010     } catch (Dali::DaliException e) {
100011       {
100012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100013       };
100014     } catch (...) {
100015       {
100016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100017       };
100018     }
100019   }
100020
100021   jresult = (void *)result;
100022   return jresult;
100023 }
100024
100025
100026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_1(void * jarg1, void * jarg2) {
100027   void * jresult ;
100028   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100029   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
100030   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
100031
100032   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100033   arg2 = (Dali::Toolkit::Ruler *)jarg2;
100034   {
100035     try {
100036       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =(arg2);
100037     } catch (std::out_of_range& e) {
100038       {
100039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100040       };
100041     } catch (std::exception& e) {
100042       {
100043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100044       };
100045     } catch (Dali::DaliException e) {
100046       {
100047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100048       };
100049     } catch (...) {
100050       {
100051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100052       };
100053     }
100054   }
100055
100056   jresult = (void *)result;
100057   return jresult;
100058 }
100059
100060
100061 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_0(void * jarg1) {
100062   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100063
100064   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100065   {
100066     try {
100067       (arg1)->Reset();
100068     } catch (std::out_of_range& e) {
100069       {
100070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100071       };
100072     } catch (std::exception& e) {
100073       {
100074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100075       };
100076     } catch (Dali::DaliException e) {
100077       {
100078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100079       };
100080     } catch (...) {
100081       {
100082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100083       };
100084     }
100085   }
100086
100087 }
100088
100089
100090 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_1(void * jarg1, void * jarg2) {
100091   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100092   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
100093
100094   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100095   arg2 = (Dali::Toolkit::Ruler *)jarg2;
100096   {
100097     try {
100098       (arg1)->Reset(arg2);
100099     } catch (std::out_of_range& e) {
100100       {
100101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100102       };
100103     } catch (std::exception& e) {
100104       {
100105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100106       };
100107     } catch (Dali::DaliException e) {
100108       {
100109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100110       };
100111     } catch (...) {
100112       {
100113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100114       };
100115     }
100116   }
100117
100118 }
100119
100120
100121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Detach(void * jarg1) {
100122   void * jresult ;
100123   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100124   Dali::Toolkit::Ruler *result = 0 ;
100125
100126   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100127   {
100128     try {
100129       result = (Dali::Toolkit::Ruler *)(arg1)->Detach();
100130     } catch (std::out_of_range& e) {
100131       {
100132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100133       };
100134     } catch (std::exception& e) {
100135       {
100136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100137       };
100138     } catch (Dali::DaliException e) {
100139       {
100140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100141       };
100142     } catch (...) {
100143       {
100144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100145       };
100146     }
100147   }
100148
100149   jresult = (void *)result;
100150   return jresult;
100151 }
100152
100153
100154 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
100155   float jresult ;
100156   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100157   float arg2 ;
100158   float arg3 ;
100159   float result;
100160
100161   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100162   arg2 = (float)jarg2;
100163   arg3 = (float)jarg3;
100164   {
100165     try {
100166       result = (float)(*arg1)->Snap(arg2,arg3);
100167     } catch (std::out_of_range& e) {
100168       {
100169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100170       };
100171     } catch (std::exception& e) {
100172       {
100173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100174       };
100175     } catch (Dali::DaliException e) {
100176       {
100177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100178       };
100179     } catch (...) {
100180       {
100181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100182       };
100183     }
100184   }
100185
100186   jresult = result;
100187   return jresult;
100188 }
100189
100190
100191 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_1(void * jarg1, float jarg2) {
100192   float jresult ;
100193   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100194   float arg2 ;
100195   float result;
100196
100197   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100198   arg2 = (float)jarg2;
100199   {
100200     try {
100201       result = (float)(*arg1)->Snap(arg2);
100202     } catch (std::out_of_range& e) {
100203       {
100204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100205       };
100206     } catch (std::exception& e) {
100207       {
100208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100209       };
100210     } catch (Dali::DaliException e) {
100211       {
100212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100213       };
100214     } catch (...) {
100215       {
100216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100217       };
100218     }
100219   }
100220
100221   jresult = result;
100222   return jresult;
100223 }
100224
100225
100226 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
100227   float jresult ;
100228   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100229   unsigned int arg2 ;
100230   unsigned int *arg3 = 0 ;
100231   bool arg4 ;
100232   float result;
100233
100234   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100235   arg2 = (unsigned int)jarg2;
100236   arg3 = (unsigned int *)jarg3;
100237   arg4 = jarg4 ? true : false;
100238   {
100239     try {
100240       result = (float)(*arg1)->GetPositionFromPage(arg2,*arg3,arg4);
100241     } catch (std::out_of_range& e) {
100242       {
100243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100244       };
100245     } catch (std::exception& e) {
100246       {
100247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100248       };
100249     } catch (Dali::DaliException e) {
100250       {
100251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100252       };
100253     } catch (...) {
100254       {
100255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100256       };
100257     }
100258   }
100259
100260   jresult = result;
100261   return jresult;
100262 }
100263
100264
100265 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
100266   unsigned int jresult ;
100267   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100268   float arg2 ;
100269   bool arg3 ;
100270   unsigned int result;
100271
100272   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100273   arg2 = (float)jarg2;
100274   arg3 = jarg3 ? true : false;
100275   {
100276     try {
100277       result = (unsigned int)(*arg1)->GetPageFromPosition(arg2,arg3);
100278     } catch (std::out_of_range& e) {
100279       {
100280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100281       };
100282     } catch (std::exception& e) {
100283       {
100284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100285       };
100286     } catch (Dali::DaliException e) {
100287       {
100288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100289       };
100290     } catch (...) {
100291       {
100292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100293       };
100294     }
100295   }
100296
100297   jresult = result;
100298   return jresult;
100299 }
100300
100301
100302 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetTotalPages(void * jarg1) {
100303   unsigned int jresult ;
100304   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100305   unsigned int result;
100306
100307   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100308   {
100309     try {
100310       result = (unsigned int)(*arg1)->GetTotalPages();
100311     } catch (std::out_of_range& e) {
100312       {
100313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100314       };
100315     } catch (std::exception& e) {
100316       {
100317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100318       };
100319     } catch (Dali::DaliException e) {
100320       {
100321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100322       };
100323     } catch (...) {
100324       {
100325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100326       };
100327     }
100328   }
100329
100330   jresult = result;
100331   return jresult;
100332 }
100333
100334
100335 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_GetType(void * jarg1) {
100336   int jresult ;
100337   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100338   Dali::Toolkit::Ruler::RulerType result;
100339
100340   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100341   {
100342     try {
100343       result = (Dali::Toolkit::Ruler::RulerType)(*arg1)->GetType();
100344     } catch (std::out_of_range& e) {
100345       {
100346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100347       };
100348     } catch (std::exception& e) {
100349       {
100350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100351       };
100352     } catch (Dali::DaliException e) {
100353       {
100354         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100355       };
100356     } catch (...) {
100357       {
100358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100359       };
100360     }
100361   }
100362
100363   jresult = (int)result;
100364   return jresult;
100365 }
100366
100367
100368 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_IsEnabled(void * jarg1) {
100369   unsigned int jresult ;
100370   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100371   bool result;
100372
100373   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100374   {
100375     try {
100376       result = (bool)(*arg1)->IsEnabled();
100377     } catch (std::out_of_range& e) {
100378       {
100379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100380       };
100381     } catch (std::exception& e) {
100382       {
100383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100384       };
100385     } catch (Dali::DaliException e) {
100386       {
100387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100388       };
100389     } catch (...) {
100390       {
100391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100392       };
100393     }
100394   }
100395
100396   jresult = result;
100397   return jresult;
100398 }
100399
100400
100401 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Enable(void * jarg1) {
100402   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100403
100404   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100405   {
100406     try {
100407       (*arg1)->Enable();
100408     } catch (std::out_of_range& e) {
100409       {
100410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100411       };
100412     } catch (std::exception& e) {
100413       {
100414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100415       };
100416     } catch (Dali::DaliException e) {
100417       {
100418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100419       };
100420     } catch (...) {
100421       {
100422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100423       };
100424     }
100425   }
100426
100427 }
100428
100429
100430 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Disable(void * jarg1) {
100431   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100432
100433   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100434   {
100435     try {
100436       (*arg1)->Disable();
100437     } catch (std::out_of_range& e) {
100438       {
100439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100440       };
100441     } catch (std::exception& e) {
100442       {
100443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100444       };
100445     } catch (Dali::DaliException e) {
100446       {
100447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100448       };
100449     } catch (...) {
100450       {
100451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100452       };
100453     }
100454   }
100455
100456 }
100457
100458
100459 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_SetDomain(void * jarg1, void * jarg2) {
100460   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100461   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
100462   Dali::Toolkit::RulerDomain *argp2 ;
100463
100464   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100465   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
100466   if (!argp2) {
100467     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
100468     return ;
100469   }
100470   arg2 = *argp2;
100471   {
100472     try {
100473       (*arg1)->SetDomain(arg2);
100474     } catch (std::out_of_range& e) {
100475       {
100476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100477       };
100478     } catch (std::exception& e) {
100479       {
100480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100481       };
100482     } catch (Dali::DaliException e) {
100483       {
100484         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100485       };
100486     } catch (...) {
100487       {
100488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100489       };
100490     }
100491   }
100492
100493 }
100494
100495
100496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_GetDomain(void * jarg1) {
100497   void * jresult ;
100498   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100499   Dali::Toolkit::RulerDomain *result = 0 ;
100500
100501   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100502   {
100503     try {
100504       result = (Dali::Toolkit::RulerDomain *) &(*arg1)->GetDomain();
100505     } catch (std::out_of_range& e) {
100506       {
100507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100508       };
100509     } catch (std::exception& e) {
100510       {
100511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100512       };
100513     } catch (Dali::DaliException e) {
100514       {
100515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100516       };
100517     } catch (...) {
100518       {
100519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100520       };
100521     }
100522   }
100523
100524   jresult = (void *)result;
100525   return jresult;
100526 }
100527
100528
100529 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_DisableDomain(void * jarg1) {
100530   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100531
100532   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100533   {
100534     try {
100535       (*arg1)->DisableDomain();
100536     } catch (std::out_of_range& e) {
100537       {
100538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100539       };
100540     } catch (std::exception& e) {
100541       {
100542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100543       };
100544     } catch (Dali::DaliException e) {
100545       {
100546         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100547       };
100548     } catch (...) {
100549       {
100550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100551       };
100552     }
100553   }
100554
100555 }
100556
100557
100558 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
100559   float jresult ;
100560   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100561   float arg2 ;
100562   float arg3 ;
100563   float arg4 ;
100564   float result;
100565
100566   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100567   arg2 = (float)jarg2;
100568   arg3 = (float)jarg3;
100569   arg4 = (float)jarg4;
100570   {
100571     try {
100572       result = (float)(*arg1)->Clamp(arg2,arg3,arg4);
100573     } catch (std::out_of_range& e) {
100574       {
100575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100576       };
100577     } catch (std::exception& e) {
100578       {
100579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100580       };
100581     } catch (Dali::DaliException e) {
100582       {
100583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100584       };
100585     } catch (...) {
100586       {
100587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100588       };
100589     }
100590   }
100591
100592   jresult = result;
100593   return jresult;
100594 }
100595
100596
100597 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
100598   float jresult ;
100599   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100600   float arg2 ;
100601   float arg3 ;
100602   float result;
100603
100604   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100605   arg2 = (float)jarg2;
100606   arg3 = (float)jarg3;
100607   {
100608     try {
100609       result = (float)(*arg1)->Clamp(arg2,arg3);
100610     } catch (std::out_of_range& e) {
100611       {
100612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100613       };
100614     } catch (std::exception& e) {
100615       {
100616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100617       };
100618     } catch (Dali::DaliException e) {
100619       {
100620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100621       };
100622     } catch (...) {
100623       {
100624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100625       };
100626     }
100627   }
100628
100629   jresult = result;
100630   return jresult;
100631 }
100632
100633
100634 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_2(void * jarg1, float jarg2) {
100635   float jresult ;
100636   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100637   float arg2 ;
100638   float result;
100639
100640   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100641   arg2 = (float)jarg2;
100642   {
100643     try {
100644       result = (float)(*arg1)->Clamp(arg2);
100645     } catch (std::out_of_range& e) {
100646       {
100647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100648       };
100649     } catch (std::exception& e) {
100650       {
100651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100652       };
100653     } catch (Dali::DaliException e) {
100654       {
100655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100656       };
100657     } catch (...) {
100658       {
100659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100660       };
100661     }
100662   }
100663
100664   jresult = result;
100665   return jresult;
100666 }
100667
100668
100669 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
100670   float jresult ;
100671   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100672   float arg2 ;
100673   float arg3 ;
100674   float arg4 ;
100675   Dali::Toolkit::ClampState *arg5 = 0 ;
100676   float result;
100677
100678   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100679   arg2 = (float)jarg2;
100680   arg3 = (float)jarg3;
100681   arg4 = (float)jarg4;
100682   arg5 = (Dali::Toolkit::ClampState *)jarg5;
100683   if (!arg5) {
100684     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
100685     return 0;
100686   }
100687   {
100688     try {
100689       result = (float)(*arg1)->Clamp(arg2,arg3,arg4,*arg5);
100690     } catch (std::out_of_range& e) {
100691       {
100692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100693       };
100694     } catch (std::exception& e) {
100695       {
100696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100697       };
100698     } catch (Dali::DaliException e) {
100699       {
100700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100701       };
100702     } catch (...) {
100703       {
100704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100705       };
100706     }
100707   }
100708
100709   jresult = result;
100710   return jresult;
100711 }
100712
100713
100714 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
100715   float jresult ;
100716   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100717   float arg2 ;
100718   float arg3 ;
100719   float arg4 ;
100720   float arg5 ;
100721   float result;
100722
100723   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100724   arg2 = (float)jarg2;
100725   arg3 = (float)jarg3;
100726   arg4 = (float)jarg4;
100727   arg5 = (float)jarg5;
100728   {
100729     try {
100730       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
100731     } catch (std::out_of_range& e) {
100732       {
100733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100734       };
100735     } catch (std::exception& e) {
100736       {
100737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100738       };
100739     } catch (Dali::DaliException e) {
100740       {
100741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100742       };
100743     } catch (...) {
100744       {
100745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100746       };
100747     }
100748   }
100749
100750   jresult = result;
100751   return jresult;
100752 }
100753
100754
100755 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
100756   float jresult ;
100757   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100758   float arg2 ;
100759   float arg3 ;
100760   float arg4 ;
100761   float result;
100762
100763   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100764   arg2 = (float)jarg2;
100765   arg3 = (float)jarg3;
100766   arg4 = (float)jarg4;
100767   {
100768     try {
100769       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4);
100770     } catch (std::out_of_range& e) {
100771       {
100772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100773       };
100774     } catch (std::exception& e) {
100775       {
100776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100777       };
100778     } catch (Dali::DaliException e) {
100779       {
100780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100781       };
100782     } catch (...) {
100783       {
100784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100785       };
100786     }
100787   }
100788
100789   jresult = result;
100790   return jresult;
100791 }
100792
100793
100794 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
100795   float jresult ;
100796   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100797   float arg2 ;
100798   float arg3 ;
100799   float result;
100800
100801   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100802   arg2 = (float)jarg2;
100803   arg3 = (float)jarg3;
100804   {
100805     try {
100806       result = (float)(*arg1)->SnapAndClamp(arg2,arg3);
100807     } catch (std::out_of_range& e) {
100808       {
100809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100810       };
100811     } catch (std::exception& e) {
100812       {
100813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100814       };
100815     } catch (Dali::DaliException e) {
100816       {
100817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100818       };
100819     } catch (...) {
100820       {
100821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100822       };
100823     }
100824   }
100825
100826   jresult = result;
100827   return jresult;
100828 }
100829
100830
100831 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
100832   float jresult ;
100833   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100834   float arg2 ;
100835   float result;
100836
100837   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100838   arg2 = (float)jarg2;
100839   {
100840     try {
100841       result = (float)(*arg1)->SnapAndClamp(arg2);
100842     } catch (std::out_of_range& e) {
100843       {
100844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100845       };
100846     } catch (std::exception& e) {
100847       {
100848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100849       };
100850     } catch (Dali::DaliException e) {
100851       {
100852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100853       };
100854     } catch (...) {
100855       {
100856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100857       };
100858     }
100859   }
100860
100861   jresult = result;
100862   return jresult;
100863 }
100864
100865
100866 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
100867   float jresult ;
100868   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100869   float arg2 ;
100870   float arg3 ;
100871   float arg4 ;
100872   float arg5 ;
100873   Dali::Toolkit::ClampState *arg6 = 0 ;
100874   float result;
100875
100876   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100877   arg2 = (float)jarg2;
100878   arg3 = (float)jarg3;
100879   arg4 = (float)jarg4;
100880   arg5 = (float)jarg5;
100881   arg6 = (Dali::Toolkit::ClampState *)jarg6;
100882   if (!arg6) {
100883     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
100884     return 0;
100885   }
100886   {
100887     try {
100888       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
100889     } catch (std::out_of_range& e) {
100890       {
100891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100892       };
100893     } catch (std::exception& e) {
100894       {
100895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100896       };
100897     } catch (Dali::DaliException e) {
100898       {
100899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100900       };
100901     } catch (...) {
100902       {
100903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100904       };
100905     }
100906   }
100907
100908   jresult = result;
100909   return jresult;
100910 }
100911
100912
100913 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reference(void * jarg1) {
100914   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100915
100916   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100917   {
100918     try {
100919       (*arg1)->Reference();
100920     } catch (std::out_of_range& e) {
100921       {
100922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100923       };
100924     } catch (std::exception& e) {
100925       {
100926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100927       };
100928     } catch (Dali::DaliException e) {
100929       {
100930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100931       };
100932     } catch (...) {
100933       {
100934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100935       };
100936     }
100937   }
100938
100939 }
100940
100941
100942 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Unreference(void * jarg1) {
100943   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100944
100945   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100946   {
100947     try {
100948       (*arg1)->Unreference();
100949     } catch (std::out_of_range& e) {
100950       {
100951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100952       };
100953     } catch (std::exception& e) {
100954       {
100955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100956       };
100957     } catch (Dali::DaliException e) {
100958       {
100959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100960       };
100961     } catch (...) {
100962       {
100963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100964       };
100965     }
100966   }
100967
100968 }
100969
100970
100971 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_ReferenceCount(void * jarg1) {
100972   int jresult ;
100973   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100974   int result;
100975
100976   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100977   {
100978     try {
100979       result = (int)(*arg1)->ReferenceCount();
100980     } catch (std::out_of_range& e) {
100981       {
100982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100983       };
100984     } catch (std::exception& e) {
100985       {
100986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100987       };
100988     } catch (Dali::DaliException e) {
100989       {
100990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100991       };
100992     } catch (...) {
100993       {
100994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100995       };
100996     }
100997   }
100998
100999   jresult = result;
101000   return jresult;
101001 }
101002
101003
101004 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Empty(void * jarg1) {
101005   unsigned int jresult ;
101006   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
101007   bool result;
101008
101009   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
101010   {
101011     try {
101012       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
101013     } catch (std::out_of_range& e) {
101014       {
101015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101016       };
101017     } catch (std::exception& e) {
101018       {
101019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101020       };
101021     } catch (Dali::DaliException e) {
101022       {
101023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
101024       };
101025     } catch (...) {
101026       {
101027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101028       };
101029     }
101030   }
101031
101032   jresult = result;
101033   return jresult;
101034 }
101035
101036
101037 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_GetConnectionCount(void * jarg1) {
101038   unsigned long jresult ;
101039   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
101040   std::size_t result;
101041
101042   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
101043   {
101044     try {
101045       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
101046     } catch (std::out_of_range& e) {
101047       {
101048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101049       };
101050     } catch (std::exception& e) {
101051       {
101052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101053       };
101054     } catch (Dali::DaliException e) {
101055       {
101056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
101057       };
101058     } catch (...) {
101059       {
101060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101061       };
101062     }
101063   }
101064
101065   jresult = (unsigned long)result;
101066   return jresult;
101067 }
101068
101069
101070 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Connect(void * jarg1, void * jarg2) {
101071   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
101072   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
101073
101074   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
101075   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
101076   {
101077     try {
101078       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
101079     } catch (std::out_of_range& e) {
101080       {
101081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101082       };
101083     } catch (std::exception& e) {
101084       {
101085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101086       };
101087     } catch (Dali::DaliException e) {
101088       {
101089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
101090       };
101091     } catch (...) {
101092       {
101093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101094       };
101095     }
101096   }
101097
101098 }
101099
101100
101101 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Disconnect(void * jarg1, void * jarg2) {
101102   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
101103   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
101104
101105   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
101106   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
101107   {
101108     try {
101109       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
101110     } catch (std::out_of_range& e) {
101111       {
101112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101113       };
101114     } catch (std::exception& e) {
101115       {
101116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101117       };
101118     } catch (Dali::DaliException e) {
101119       {
101120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
101121       };
101122     } catch (...) {
101123       {
101124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101125       };
101126     }
101127   }
101128
101129 }
101130
101131
101132 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Emit(void * jarg1, void * jarg2) {
101133   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
101134   Dali::Toolkit::Control arg2 ;
101135   Dali::Toolkit::Control *argp2 ;
101136
101137   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
101138   argp2 = (Dali::Toolkit::Control *)jarg2;
101139   if (!argp2) {
101140     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
101141     return ;
101142   }
101143   arg2 = *argp2;
101144   {
101145     try {
101146       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
101147     } catch (std::out_of_range& e) {
101148       {
101149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101150       };
101151     } catch (std::exception& e) {
101152       {
101153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101154       };
101155     } catch (Dali::DaliException e) {
101156       {
101157         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
101158       };
101159     } catch (...) {
101160       {
101161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101162       };
101163     }
101164   }
101165
101166 }
101167
101168
101169 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewResourceReadySignal() {
101170   void * jresult ;
101171   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
101172
101173   {
101174     try {
101175       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
101176     } catch (std::out_of_range& e) {
101177       {
101178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101179       };
101180     } catch (std::exception& e) {
101181       {
101182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101183       };
101184     } catch (Dali::DaliException e) {
101185       {
101186         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
101187       };
101188     } catch (...) {
101189       {
101190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101191       };
101192     }
101193   }
101194
101195   jresult = (void *)result;
101196   return jresult;
101197 }
101198
101199
101200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewResourceReadySignal(void * jarg1) {
101201   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
101202
101203   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
101204   {
101205     try {
101206       delete arg1;
101207     } catch (std::out_of_range& e) {
101208       {
101209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101210       };
101211     } catch (std::exception& e) {
101212       {
101213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101214       };
101215     } catch (Dali::DaliException e) {
101216       {
101217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
101218       };
101219     } catch (...) {
101220       {
101221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101222       };
101223     }
101224   }
101225
101226 }
101227
101228 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_GetRefObjectPtr(Dali::BaseHandle *arg1) {
101229   Dali::RefObject *result = NULL;
101230
101231   if (arg1)
101232   {
101233     result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
101234   }
101235   return result;
101236 }
101237
101238 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_BaseObject_SWIGUpcast(Dali::BaseObject *jarg1) {
101239     return (Dali::RefObject *)jarg1;
101240 }
101241
101242 SWIGEXPORT Dali::SignalObserver * SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SWIGUpcast(Dali::ConnectionTrackerInterface *jarg1) {
101243     return (Dali::SignalObserver *)jarg1;
101244 }
101245
101246 SWIGEXPORT Dali::ConnectionTrackerInterface * SWIGSTDCALL CSharp_Dali_ConnectionTracker_SWIGUpcast(Dali::ConnectionTracker *jarg1) {
101247     return (Dali::ConnectionTrackerInterface *)jarg1;
101248 }
101249
101250 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ObjectRegistry_SWIGUpcast(Dali::ObjectRegistry *jarg1) {
101251     return (Dali::BaseHandle *)jarg1;
101252 }
101253
101254 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyCondition_SWIGUpcast(Dali::PropertyCondition *jarg1) {
101255     return (Dali::BaseHandle *)jarg1;
101256 }
101257
101258 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyNotification_SWIGUpcast(Dali::PropertyNotification *jarg1) {
101259     return (Dali::BaseHandle *)jarg1;
101260 }
101261
101262 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Handle_SWIGUpcast(Dali::Handle *jarg1) {
101263     return (Dali::BaseHandle *)jarg1;
101264 }
101265
101266 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeInfo_SWIGUpcast(Dali::TypeInfo *jarg1) {
101267     return (Dali::BaseHandle *)jarg1;
101268 }
101269
101270 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeRegistry_SWIGUpcast(Dali::TypeRegistry *jarg1) {
101271     return (Dali::BaseHandle *)jarg1;
101272 }
101273
101274 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Image_SWIGUpcast(Dali::Image *jarg1) {
101275     return (Dali::BaseHandle *)jarg1;
101276 }
101277
101278 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelData_SWIGUpcast(Dali::PixelData *jarg1) {
101279     return (Dali::BaseHandle *)jarg1;
101280 }
101281
101282 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Texture_SWIGUpcast(Dali::Texture *jarg1) {
101283     return (Dali::BaseHandle *)jarg1;
101284 }
101285
101286 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Sampler_SWIGUpcast(Dali::Sampler *jarg1) {
101287     return (Dali::BaseHandle *)jarg1;
101288 }
101289
101290 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TextureSet_SWIGUpcast(Dali::TextureSet *jarg1) {
101291     return (Dali::BaseHandle *)jarg1;
101292 }
101293
101294 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyBuffer_SWIGUpcast(Dali::PropertyBuffer *jarg1) {
101295     return (Dali::BaseHandle *)jarg1;
101296 }
101297
101298 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Geometry_SWIGUpcast(Dali::Geometry *jarg1) {
101299     return (Dali::BaseHandle *)jarg1;
101300 }
101301
101302 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Shader_SWIGUpcast(Dali::Shader *jarg1) {
101303     return (Dali::Handle *)jarg1;
101304 }
101305
101306 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Renderer_SWIGUpcast(Dali::Renderer *jarg1) {
101307     return (Dali::Handle *)jarg1;
101308 }
101309
101310 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_FrameBuffer_SWIGUpcast(Dali::FrameBuffer *jarg1) {
101311     return (Dali::BaseHandle *)jarg1;
101312 }
101313
101314 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_RenderTaskList_SWIGUpcast(Dali::RenderTaskList *jarg1) {
101315     return (Dali::BaseHandle *)jarg1;
101316 }
101317
101318 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_RenderTask_SWIGUpcast(Dali::RenderTask *jarg1) {
101319     return (Dali::Handle *)jarg1;
101320 }
101321
101322 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Touch_SWIGUpcast(Dali::TouchData *jarg1) {
101323     return (Dali::BaseHandle *)jarg1;
101324 }
101325
101326 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_GestureDetector_SWIGUpcast(Dali::GestureDetector *jarg1) {
101327     return (Dali::Handle *)jarg1;
101328 }
101329
101330 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SWIGUpcast(Dali::LongPressGestureDetector *jarg1) {
101331     return (Dali::GestureDetector *)jarg1;
101332 }
101333
101334 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_LongPressGesture_SWIGUpcast(Dali::LongPressGesture *jarg1) {
101335     return (Dali::Gesture *)jarg1;
101336 }
101337
101338 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Actor_SWIGUpcast(Dali::Actor *jarg1) {
101339     return (Dali::Handle *)jarg1;
101340 }
101341
101342 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_Layer_SWIGUpcast(Dali::Layer *jarg1) {
101343     return (Dali::Actor *)jarg1;
101344 }
101345
101346 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Stage_SWIGUpcast(Dali::Stage *jarg1) {
101347     return (Dali::BaseHandle *)jarg1;
101348 }
101349
101350 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_CustomActorImpl_SWIGUpcast(Dali::CustomActorImpl *jarg1) {
101351     return (Dali::RefObject *)jarg1;
101352 }
101353
101354 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CustomActor_SWIGUpcast(Dali::CustomActor *jarg1) {
101355     return (Dali::Actor *)jarg1;
101356 }
101357
101358 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PanGestureDetector_SWIGUpcast(Dali::PanGestureDetector *jarg1) {
101359     return (Dali::GestureDetector *)jarg1;
101360 }
101361
101362 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PanGesture_SWIGUpcast(Dali::PanGesture *jarg1) {
101363     return (Dali::Gesture *)jarg1;
101364 }
101365
101366 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_SWIGUpcast(Dali::PinchGestureDetector *jarg1) {
101367     return (Dali::GestureDetector *)jarg1;
101368 }
101369
101370 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PinchGesture_SWIGUpcast(Dali::PinchGesture *jarg1) {
101371     return (Dali::Gesture *)jarg1;
101372 }
101373
101374 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_TapGestureDetector_SWIGUpcast(Dali::TapGestureDetector *jarg1) {
101375     return (Dali::GestureDetector *)jarg1;
101376 }
101377
101378 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_TapGesture_SWIGUpcast(Dali::TapGesture *jarg1) {
101379     return (Dali::Gesture *)jarg1;
101380 }
101381
101382 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyFrames_SWIGUpcast(Dali::KeyFrames *jarg1) {
101383     return (Dali::BaseHandle *)jarg1;
101384 }
101385
101386 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Path_SWIGUpcast(Dali::Path *jarg1) {
101387     return (Dali::Handle *)jarg1;
101388 }
101389
101390 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_LinearConstrainer_SWIGUpcast(Dali::LinearConstrainer *jarg1) {
101391     return (Dali::Handle *)jarg1;
101392 }
101393
101394 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_PathConstrainer_SWIGUpcast(Dali::PathConstrainer *jarg1) {
101395     return (Dali::Handle *)jarg1;
101396 }
101397
101398 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_BufferImage_SWIGUpcast(Dali::BufferImage *jarg1) {
101399     return (Dali::Image *)jarg1;
101400 }
101401
101402 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_SWIGUpcast(Dali::EncodedBufferImage *jarg1) {
101403     return (Dali::Image *)jarg1;
101404 }
101405
101406 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_NativeImage_SWIGUpcast(Dali::NativeImage *jarg1) {
101407     return (Dali::Image *)jarg1;
101408 }
101409
101410 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_NativeImageInterface_SWIGUpcast(Dali::NativeImageInterface *jarg1) {
101411     return (Dali::RefObject *)jarg1;
101412 }
101413
101414 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_ResourceImage_SWIGUpcast(Dali::ResourceImage *jarg1) {
101415     return (Dali::Image *)jarg1;
101416 }
101417
101418 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_FrameBufferImage_SWIGUpcast(Dali::FrameBufferImage *jarg1) {
101419     return (Dali::Image *)jarg1;
101420 }
101421
101422 SWIGEXPORT Dali::ResourceImage * SWIGSTDCALL CSharp_Dali_NinePatchImage_SWIGUpcast(Dali::NinePatchImage *jarg1) {
101423     return (Dali::ResourceImage *)jarg1;
101424 }
101425
101426 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CameraActor_SWIGUpcast(Dali::CameraActor *jarg1) {
101427     return (Dali::Actor *)jarg1;
101428 }
101429
101430 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Timer_SWIGUpcast(Dali::Timer *jarg1) {
101431     return (Dali::BaseHandle *)jarg1;
101432 }
101433
101434 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_SWIGUpcast(Dali::DragAndDropDetector *jarg1) {
101435     return (Dali::BaseHandle *)jarg1;
101436 }
101437
101438
101439 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Builder_SWIGUpcast(Dali::Toolkit::Builder *jarg1) {
101440     return (Dali::BaseHandle *)jarg1;
101441 }
101442
101443 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TransitionData_SWIGUpcast(Dali::Toolkit::TransitionData *jarg1) {
101444     return (Dali::BaseHandle *)jarg1;
101445 }
101446
101447 SWIGEXPORT Dali::CustomActorImpl * SWIGSTDCALL CSharp_Dali_ViewImpl_SWIGUpcast(Dali::Toolkit::Internal::Control *jarg1) {
101448     return (Dali::CustomActorImpl *)jarg1;
101449 }
101450
101451 SWIGEXPORT Dali::CustomActor * SWIGSTDCALL CSharp_Dali_View_SWIGUpcast(Dali::Toolkit::Control *jarg1) {
101452     return (Dali::CustomActor *)jarg1;
101453 }
101454
101455 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SWIGUpcast(Dali::Toolkit::KeyInputFocusManager *jarg1) {
101456     return (Dali::BaseHandle *)jarg1;
101457 }
101458
101459 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Alignment_SWIGUpcast(Dali::Toolkit::Alignment *jarg1) {
101460     return (Dali::Toolkit::Control *)jarg1;
101461 }
101462
101463 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Button_SWIGUpcast(Dali::Toolkit::Button *jarg1) {
101464     return (Dali::Toolkit::Control *)jarg1;
101465 }
101466
101467 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_CheckBoxButton_SWIGUpcast(Dali::Toolkit::CheckBoxButton *jarg1) {
101468     return (Dali::Toolkit::Button *)jarg1;
101469 }
101470
101471 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_PushButton_SWIGUpcast(Dali::Toolkit::PushButton *jarg1) {
101472     return (Dali::Toolkit::Button *)jarg1;
101473 }
101474
101475 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_RadioButton_SWIGUpcast(Dali::Toolkit::RadioButton *jarg1) {
101476     return (Dali::Toolkit::Button *)jarg1;
101477 }
101478
101479 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_FlexContainer_SWIGUpcast(Dali::Toolkit::FlexContainer *jarg1) {
101480     return (Dali::Toolkit::Control *)jarg1;
101481 }
101482
101483 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ImageView_SWIGUpcast(Dali::Toolkit::ImageView *jarg1) {
101484     return (Dali::Toolkit::Control *)jarg1;
101485 }
101486
101487 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Model3dView_SWIGUpcast(Dali::Toolkit::Model3dView *jarg1) {
101488     return (Dali::Toolkit::Control *)jarg1;
101489 }
101490
101491 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ScrollBar_SWIGUpcast(Dali::Toolkit::ScrollBar *jarg1) {
101492     return (Dali::Toolkit::Control *)jarg1;
101493 }
101494
101495 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Scrollable_SWIGUpcast(Dali::Toolkit::Scrollable *jarg1) {
101496     return (Dali::Toolkit::Control *)jarg1;
101497 }
101498
101499 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_ItemLayout_SWIGUpcast(Dali::Toolkit::ItemLayout *jarg1) {
101500     return (Dali::RefObject *)jarg1;
101501 }
101502
101503 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ItemView_SWIGUpcast(Dali::Toolkit::ItemView *jarg1) {
101504     return (Dali::Toolkit::Scrollable *)jarg1;
101505 }
101506
101507 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ScrollViewEffect_SWIGUpcast(Dali::Toolkit::ScrollViewEffect *jarg1) {
101508     return (Dali::BaseHandle *)jarg1;
101509 }
101510
101511 SWIGEXPORT Dali::Toolkit::ScrollViewEffect * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_SWIGUpcast(Dali::Toolkit::ScrollViewPagePathEffect *jarg1) {
101512     return (Dali::Toolkit::ScrollViewEffect *)jarg1;
101513 }
101514
101515 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_Ruler_SWIGUpcast(Dali::Toolkit::Ruler *jarg1) {
101516     return (Dali::RefObject *)jarg1;
101517 }
101518
101519 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_DefaultRuler_SWIGUpcast(Dali::Toolkit::DefaultRuler *jarg1) {
101520     return (Dali::Toolkit::Ruler *)jarg1;
101521 }
101522
101523 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_FixedRuler_SWIGUpcast(Dali::Toolkit::FixedRuler *jarg1) {
101524     return (Dali::Toolkit::Ruler *)jarg1;
101525 }
101526
101527 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ScrollView_SWIGUpcast(Dali::Toolkit::ScrollView *jarg1) {
101528     return (Dali::Toolkit::Scrollable *)jarg1;
101529 }
101530
101531 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TableView_SWIGUpcast(Dali::Toolkit::TableView *jarg1) {
101532     return (Dali::Toolkit::Control *)jarg1;
101533 }
101534
101535
101536 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextLabel_SWIGUpcast(Dali::Toolkit::TextLabel *jarg1) {
101537     return (Dali::Toolkit::Control *)jarg1;
101538 }
101539
101540 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AccessibilityManager_SWIGUpcast(Dali::Toolkit::AccessibilityManager *jarg1) {
101541     return (Dali::BaseHandle *)jarg1;
101542 }
101543
101544 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_StyleManager_SWIGUpcast(Dali::Toolkit::StyleManager *jarg1) {
101545     return (Dali::BaseHandle *)jarg1;
101546 }
101547
101548 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Slider_SWIGUpcast(Dali::Toolkit::Slider *jarg1) {
101549     return (Dali::Toolkit::Control *)jarg1;
101550 }
101551
101552 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_VideoView_SWIGUpcast(Dali::Toolkit::VideoView *jarg1) {
101553     return (Dali::Toolkit::Control *)jarg1;
101554 }
101555
101556 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Popup_SWIGUpcast(Dali::Toolkit::Popup *jarg1) {
101557     return (Dali::Toolkit::Control *)jarg1;
101558 }
101559
101560 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ProgressBar_SWIGUpcast(Dali::Toolkit::ProgressBar *jarg1) {
101561     return (Dali::Toolkit::Control *)jarg1;
101562 }
101563
101564 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_GaussianBlurView_SWIGUpcast(Dali::Toolkit::GaussianBlurView *jarg1) {
101565     return (Dali::Toolkit::Control *)jarg1;
101566 }
101567
101568 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_PageTurnView_SWIGUpcast(Dali::Toolkit::PageTurnView *jarg1) {
101569     return (Dali::Toolkit::Control *)jarg1;
101570 }
101571
101572 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_SWIGUpcast(Dali::Toolkit::PageTurnLandscapeView *jarg1) {
101573     return (Dali::Toolkit::PageTurnView *)jarg1;
101574 }
101575
101576 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_SWIGUpcast(Dali::Toolkit::PageTurnPortraitView *jarg1) {
101577     return (Dali::Toolkit::PageTurnView *)jarg1;
101578 }
101579
101580 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_ToggleButton_SWIGUpcast(Dali::Toolkit::ToggleButton *jarg1) {
101581     return (Dali::Toolkit::Button *)jarg1;
101582 }
101583
101584 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualBase_SWIGUpcast(Dali::Toolkit::Visual::Base *jarg1) {
101585     return (Dali::BaseHandle *)jarg1;
101586 }
101587
101588 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualFactory_SWIGUpcast(Dali::Toolkit::VisualFactory *jarg1) {
101589     return (Dali::BaseHandle *)jarg1;
101590 }
101591
101592 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_SWIGUpcast(Dali::Toolkit::AsyncImageLoader *jarg1) {
101593     return (Dali::BaseHandle *)jarg1;
101594 }
101595
101596 /*
101597  * Widget binding
101598  */
101599 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Widget_SWIGUpcast(Dali::Widget *jarg1) {
101600     return (Dali::BaseHandle *)jarg1;
101601 }
101602
101603 SWIGEXPORT Dali::BaseObject * SWIGSTDCALL CSharp_Dali_WidgetImpl_SWIGUpcast(Dali::Internal::Adaptor::Widget *jarg1) {
101604     return (Dali::BaseObject *)jarg1;
101605 }
101606
101607 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_0() {
101608   void * jresult ;
101609   Dali::Widget result;
101610
101611   {
101612     try {
101613       result = Dali::Widget::New();
101614     } catch (std::out_of_range& e) {
101615       {
101616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101617       };
101618     } catch (std::exception& e) {
101619       {
101620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101621       };
101622     } catch (...) {
101623       {
101624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101625       };
101626     }
101627   }
101628   jresult = new Dali::Widget((const Dali::Widget &)result);
101629   return jresult;
101630 }
101631
101632
101633 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_1(void * jarg1) {
101634   void * jresult ;
101635   Dali::Internal::Adaptor::Widget *arg1 = 0 ;
101636   Dali::Widget result;
101637
101638   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101639
101640   if (!arg1) {
101641     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Internal::Adaptor::Widget & type is null", 0);
101642     return 0;
101643   }
101644   {
101645     try {
101646       jresult = new Dali::Widget(arg1);
101647     } catch (std::out_of_range& e) {
101648       {
101649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101650       };
101651     } catch (std::exception& e) {
101652       {
101653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101654       };
101655     } catch (...) {
101656       {
101657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101658       };
101659     }
101660   }
101661   return jresult;
101662 }
101663
101664
101665 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Widget() {
101666   void * jresult ;
101667   Dali::Widget *result = 0 ;
101668
101669   {
101670     try {
101671       result = (Dali::Widget *)new Dali::Widget();
101672     } catch (std::out_of_range& e) {
101673       {
101674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101675       };
101676     } catch (std::exception& e) {
101677       {
101678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101679       };
101680     } catch (...) {
101681       {
101682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101683       };
101684     }
101685   }
101686   jresult = (void *)result;
101687   return jresult;
101688 }
101689
101690
101691 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_Assign(void * jarg1, void * jarg2) {
101692   void * jresult ;
101693   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
101694   Dali::Widget *arg2 = 0 ;
101695   Dali::Widget *result = 0 ;
101696
101697   arg1 = (Dali::Widget *)jarg1;
101698   arg2 = (Dali::Widget *)jarg2;
101699   if (!arg2) {
101700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget const & type is null", 0);
101701     return 0;
101702   }
101703   {
101704     try {
101705       result = (Dali::Widget *) &(arg1)->operator =((Dali::Widget const &)*arg2);
101706     } catch (std::out_of_range& e) {
101707       {
101708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101709       };
101710     } catch (std::exception& e) {
101711       {
101712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101713       };
101714     } catch (...) {
101715       {
101716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101717       };
101718     }
101719   }
101720   jresult = (void *)result;
101721   return jresult;
101722 }
101723
101724
101725 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Widget(void * jarg1) {
101726   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
101727
101728   arg1 = (Dali::Widget *)jarg1;
101729   {
101730     try {
101731       delete arg1;
101732     } catch (std::out_of_range& e) {
101733       {
101734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101735       };
101736     } catch (std::exception& e) {
101737       {
101738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101739       };
101740     } catch (...) {
101741       {
101742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101743       };
101744     }
101745   }
101746 }
101747
101748
101749 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetImpl_New() {
101750   void * jresult ;
101751   SwigDirector_WidgetImpl* result;
101752   {
101753     try {
101754       result = new SwigDirector_WidgetImpl();
101755     } catch (std::out_of_range& e) {
101756       {
101757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101758       };
101759     } catch (std::exception& e) {
101760       {
101761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101762       };
101763     } catch (...) {
101764       {
101765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101766       };
101767     }
101768   }
101769   jresult = result;
101770   return jresult;
101771 }
101772
101773
101774 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreate(void * jarg1, char * jarg2, void * jarg3) {
101775   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101776   std::string *arg2 = 0 ;
101777   Dali::Window arg3 ;
101778   Dali::Window *argp3 ;
101779
101780   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101781   if (!jarg2) {
101782     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101783     return ;
101784   }
101785   std::string arg2_str(jarg2);
101786   arg2 = &arg2_str;
101787   argp3 = (Dali::Window *)jarg3;
101788   if (!argp3) {
101789     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
101790     return ;
101791   }
101792   arg3 = *argp3;
101793   {
101794     try {
101795       (arg1)->OnCreate((std::string const &)*arg2,arg3);
101796     } catch (std::out_of_range& e) {
101797       {
101798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101799       };
101800     } catch (std::exception& e) {
101801       {
101802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101803       };
101804     } catch (...) {
101805       {
101806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101807       };
101808     }
101809   }
101810 }
101811
101812 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, void * jarg3) {
101813   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101814   std::string *arg2 = 0 ;
101815   Dali::Window arg3 ;
101816   Dali::Window *argp3 ;
101817
101818   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101819   if (!jarg2) {
101820     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101821     return ;
101822   }
101823   std::string arg2_str(jarg2);
101824   arg2 = &arg2_str;
101825   argp3 = (Dali::Window *)jarg3;
101826   if (!argp3) {
101827     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
101828     return ;
101829   }
101830   arg3 = *argp3;
101831   {
101832     try {
101833       (arg1)->Dali::Internal::Adaptor::Widget::OnCreate((std::string const &)*arg2,arg3);
101834     } catch (std::out_of_range& e) {
101835       {
101836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101837       };
101838     } catch (std::exception& e) {
101839       {
101840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101841       };
101842     } catch (...) {
101843       {
101844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101845       };
101846     }
101847   }
101848 }
101849
101850
101851 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminate(void * jarg1, char * jarg2, int jarg3) {
101852   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101853   std::string *arg2 = 0 ;
101854   Dali::Widget::Termination arg3 ;
101855
101856   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101857   if (!jarg2) {
101858     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101859     return ;
101860   }
101861   std::string arg2_str(jarg2);
101862   arg2 = &arg2_str;
101863   arg3 = (Dali::Widget::Termination)jarg3;
101864   {
101865     try {
101866       (arg1)->OnTerminate((std::string const &)*arg2,arg3);
101867     } catch (std::out_of_range& e) {
101868       {
101869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101870       };
101871     } catch (std::exception& e) {
101872       {
101873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101874       };
101875     } catch (...) {
101876       {
101877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101878       };
101879     }
101880   }
101881 }
101882
101883 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
101884   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101885   std::string *arg2 = 0 ;
101886   Dali::Widget::Termination arg3 ;
101887
101888   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101889   if (!jarg2) {
101890     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101891     return ;
101892   }
101893   std::string arg2_str(jarg2);
101894   arg2 = &arg2_str;
101895   arg3 = (Dali::Widget::Termination)jarg3;
101896   {
101897     try {
101898       (arg1)->Dali::Internal::Adaptor::Widget::OnTerminate((std::string const &)*arg2,arg3);
101899     } catch (std::out_of_range& e) {
101900       {
101901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101902       };
101903     } catch (std::exception& e) {
101904       {
101905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101906       };
101907     } catch (...) {
101908       {
101909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101910       };
101911     }
101912   }
101913 }
101914
101915
101916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPause(void * jarg1) {
101917   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101918
101919   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101920   {
101921     try {
101922       (arg1)->OnPause();
101923     } catch (std::out_of_range& e) {
101924       {
101925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101926       };
101927     } catch (std::exception& e) {
101928       {
101929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101930       };
101931     } catch (...) {
101932       {
101933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101934       };
101935     }
101936   }
101937 }
101938
101939 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPauseSwigExplicitWidgetImpl(void * jarg1) {
101940   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101941
101942   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101943   {
101944     try {
101945       (arg1)->Dali::Internal::Adaptor::Widget::OnPause();
101946     } catch (std::out_of_range& e) {
101947       {
101948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101949       };
101950     } catch (std::exception& e) {
101951       {
101952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101953       };
101954     } catch (...) {
101955       {
101956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101957       };
101958     }
101959   }
101960 }
101961
101962
101963 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResume(void * jarg1) {
101964   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101965
101966   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101967   {
101968     try {
101969       (arg1)->OnResume();
101970     } catch (std::out_of_range& e) {
101971       {
101972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101973       };
101974     } catch (std::exception& e) {
101975       {
101976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101977       };
101978     } catch (...) {
101979       {
101980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101981       };
101982     }
101983   }
101984 }
101985
101986
101987 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResumeSwigExplicitWidgetImpl(void * jarg1) {
101988   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101989
101990   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101991   {
101992     try {
101993       (arg1)->Dali::Internal::Adaptor::Widget::OnResume();
101994     } catch (std::out_of_range& e) {
101995       {
101996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101997       };
101998     } catch (std::exception& e) {
101999       {
102000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102001       };
102002     } catch (...) {
102003       {
102004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102005       };
102006     }
102007   }
102008 }
102009
102010
102011 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResize(void * jarg1, void * jarg2) {
102012   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
102013   Dali::Window arg2 ;
102014   Dali::Window *argp2 ;
102015
102016   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
102017   argp2 = (Dali::Window *)jarg2;
102018   if (!argp2) {
102019     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
102020     return ;
102021   }
102022   arg2 = *argp2;
102023   {
102024     try {
102025       (arg1)->OnResize(arg2);
102026     } catch (std::out_of_range& e) {
102027       {
102028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102029       };
102030     } catch (std::exception& e) {
102031       {
102032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102033       };
102034     } catch (...) {
102035       {
102036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102037       };
102038     }
102039   }
102040 }
102041
102042 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResizeSwigExplicitWidgetImpl(void * jarg1, void * jarg2) {
102043   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
102044   Dali::Window arg2 ;
102045   Dali::Window *argp2 ;
102046
102047   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
102048   argp2 = (Dali::Window *)jarg2;
102049   if (!argp2) {
102050     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
102051     return ;
102052   }
102053   arg2 = *argp2;
102054   {
102055     try {
102056       (arg1)->Dali::Internal::Adaptor::Widget::OnResize(arg2);
102057     } catch (std::out_of_range& e) {
102058       {
102059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102060       };
102061     } catch (std::exception& e) {
102062       {
102063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102064       };
102065     } catch (...) {
102066       {
102067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102068       };
102069     }
102070   }
102071 }
102072
102073
102074 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdate(void * jarg1, char * jarg2, int jarg3) {
102075   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
102076   std::string *arg2 = 0 ;
102077   int arg3 ;
102078
102079   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
102080   if (!jarg2) {
102081     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102082     return ;
102083   }
102084   std::string arg2_str(jarg2);
102085   arg2 = &arg2_str;
102086   arg3 = (int)jarg3;
102087   {
102088     try {
102089       (arg1)->OnUpdate((std::string const &)*arg2,arg3);
102090     } catch (std::out_of_range& e) {
102091       {
102092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102093       };
102094     } catch (std::exception& e) {
102095       {
102096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102097       };
102098     } catch (...) {
102099       {
102100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102101       };
102102     }
102103   }
102104 }
102105
102106 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
102107   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
102108   std::string *arg2 = 0 ;
102109   int arg3 ;
102110
102111   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
102112   if (!jarg2) {
102113     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102114     return ;
102115   }
102116   std::string arg2_str(jarg2);
102117   arg2 = &arg2_str;
102118   arg3 = (int)jarg3;
102119   {
102120     try {
102121       (arg1)->Dali::Internal::Adaptor::Widget::OnUpdate((std::string const &)*arg2,arg3);
102122     } catch (std::out_of_range& e) {
102123       {
102124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102125       };
102126     } catch (std::exception& e) {
102127       {
102128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102129       };
102130     } catch (...) {
102131       {
102132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102133       };
102134     }
102135   }
102136 }
102137
102138
102139 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
102140   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
102141   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
102142   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
102143
102144   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
102145   arg2 = (Dali::SlotObserver *)jarg2;
102146   arg3 = (Dali::CallbackBase *)jarg3;
102147   {
102148     try {
102149       (arg1)->SignalConnected(arg2,arg3);
102150     } catch (std::out_of_range& e) {
102151       {
102152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102153       };
102154     } catch (std::exception& e) {
102155       {
102156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102157       };
102158     } catch (...) {
102159       {
102160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102161       };
102162     }
102163   }
102164 }
102165
102166 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
102167   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
102168   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
102169   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
102170
102171   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
102172   arg2 = (Dali::SlotObserver *)jarg2;
102173   arg3 = (Dali::CallbackBase *)jarg3;
102174   {
102175     try {
102176       (arg1)->Dali::Internal::Adaptor::Widget::SignalConnected(arg2,arg3);
102177     } catch (std::out_of_range& e) {
102178       {
102179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102180       };
102181     } catch (std::exception& e) {
102182       {
102183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102184       };
102185     } catch (...) {
102186       {
102187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102188       };
102189     }
102190   }
102191 }
102192
102193
102194 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
102195   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
102196   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
102197   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
102198
102199   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
102200   arg2 = (Dali::SlotObserver *)jarg2;
102201   arg3 = (Dali::CallbackBase *)jarg3;
102202   {
102203     try {
102204       (arg1)->SignalDisconnected(arg2,arg3);
102205     } catch (std::out_of_range& e) {
102206       {
102207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102208       };
102209     } catch (std::exception& e) {
102210       {
102211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102212       };
102213     } catch (...) {
102214       {
102215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102216       };
102217     }
102218   }
102219 }
102220
102221 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
102222   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
102223   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
102224   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
102225
102226   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
102227   arg2 = (Dali::SlotObserver *)jarg2;
102228   arg3 = (Dali::CallbackBase *)jarg3;
102229   {
102230     try {
102231       (arg1)->Dali::Internal::Adaptor::Widget::SignalDisconnected(arg2,arg3);
102232     } catch (std::out_of_range& e) {
102233       {
102234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102235       };
102236     } catch (std::exception& e) {
102237       {
102238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102239       };
102240     } catch (...) {
102241       {
102242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102243       };
102244     }
102245   }
102246 }
102247
102248 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetContentInfo(void * jarg1, char * jarg2) {
102249   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
102250   std::string *arg2 = 0 ;
102251
102252   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
102253   if (!jarg2) {
102254     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102255     return ;
102256   }
102257   std::string arg2_str(jarg2);
102258   arg2 = &arg2_str;
102259   {
102260     try {
102261       (arg1)->SetContentInfo((std::string const &)*arg2);
102262     } catch (std::out_of_range& e) {
102263       {
102264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102265       };
102266     } catch (std::exception& e) {
102267       {
102268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102269       };
102270     } catch (...) {
102271       {
102272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102273       };
102274     }
102275   }
102276 }
102277
102278
102279 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetImpl(void * jarg1, void * jarg2) {
102280   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
102281   Dali::Internal::Adaptor::Widget::Impl *arg2 = (Dali::Internal::Adaptor::Widget::Impl *) 0 ;
102282
102283   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
102284   arg2 = (Dali::Internal::Adaptor::Widget::Impl *)jarg2;
102285   {
102286     try {
102287       (arg1)->SetImpl(arg2);
102288     } catch (std::out_of_range& e) {
102289       {
102290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102291       };
102292     } catch (std::exception& e) {
102293       {
102294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102295       };
102296     } catch (...) {
102297       {
102298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102299       };
102300     }
102301   }
102302 }
102303
102304 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) {
102305
102306   SwigDirector_WidgetImpl *director = static_cast<SwigDirector_WidgetImpl *>(objarg);
102307   if (director) {
102308     director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5, callback6, callback7);
102309   }
102310 }
102311
102312 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_GetImplementation__SWIG_0(void * jarg1) {
102313   void * jresult ;
102314   Dali::Widget *arg1 = 0 ;
102315   SwigDirector_WidgetImpl *result = 0 ;
102316
102317   arg1 = (Dali::Widget *)jarg1;
102318   if (!arg1) {
102319     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget & type is null", 0);
102320     return 0;
102321   }
102322   {
102323     try {
102324       result = (SwigDirector_WidgetImpl *) &Dali::Internal::Adaptor::GetImplementation(*arg1);
102325     } catch (std::out_of_range& e) {
102326       {
102327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102328       };
102329     } catch (std::exception& e) {
102330       {
102331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102332       };
102333     } catch (...) {
102334       {
102335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102336       };
102337     }
102338   }
102339
102340   jresult = (void *)result;
102341   return jresult;
102342 }
102343
102344
102345 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_New(int jarg1, char * jarg2, char * jarg3) {
102346   void * jresult ;
102347   int *arg1 = (int *) 0 ;
102348   char ***arg2 ;
102349   std::string *arg3 = 0 ;
102350   Dali::WidgetApplication result;
102351   {
102352     int index = 0;
102353     int length = 0;
102354     char *retPtr;
102355     char *nextPtr;
102356     argWidgetC = jarg1;
102357     argWidgetV = new char*[jarg1 + 1];
102358
102359     retPtr = strtok_r( jarg2, " ", &nextPtr);
102360     if( retPtr )
102361     {
102362       length = strlen(retPtr);
102363     }
102364     argWidgetV[index] = new char[length + 1];
102365     if( retPtr )
102366     {
102367       strncpy(argWidgetV[index], retPtr, length);
102368     }
102369     argWidgetV[index][length] = '\0';
102370     index++;
102371
102372     while (index < jarg1)
102373     {
102374       length = 0;
102375       retPtr = strtok_r(NULL, " ", &nextPtr);
102376       if( retPtr )
102377       {
102378         length = strlen(retPtr);
102379       }
102380       argWidgetV[index] = new char[length + 1];
102381       if( retPtr )
102382       {
102383         strncpy(argWidgetV[index], retPtr, length);
102384       }
102385       argWidgetV[index][length] = '\0';
102386       index++;
102387     }
102388
102389     argWidgetV[jarg1] = NULL;
102390     argWidgetC = jarg1;
102391
102392     arg1 = &argWidgetC;
102393     arg2 = &argWidgetV;
102394   }
102395
102396   if (!jarg3) {
102397     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102398     return 0;
102399   }
102400   std::string arg3_str(jarg3);
102401   arg3 = &arg3_str;
102402   {
102403     try {
102404       result = Dali::WidgetApplication::New(arg1,arg2,(std::string const &)*arg3);
102405     } catch (std::out_of_range& e) {
102406       {
102407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102408       };
102409     } catch (std::exception& e) {
102410       {
102411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102412       };
102413     } catch (...) {
102414       {
102415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102416       };
102417     }
102418   }
102419   jresult = new Dali::WidgetApplication((const Dali::WidgetApplication &)result);
102420
102421   return jresult;
102422 }
102423
102424
102425 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_0() {
102426   void * jresult ;
102427   Dali::WidgetApplication *result = 0 ;
102428
102429   {
102430     try {
102431       result = (Dali::WidgetApplication *)new Dali::WidgetApplication();
102432     } catch (std::out_of_range& e) {
102433       {
102434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102435       };
102436     } catch (std::exception& e) {
102437       {
102438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102439       };
102440     } catch (...) {
102441       {
102442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102443       };
102444     }
102445   }
102446   jresult = (void *)result;
102447   return jresult;
102448 }
102449
102450
102451 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_1(void * jarg1) {
102452   void * jresult ;
102453   Dali::WidgetApplication *arg1 = 0 ;
102454   Dali::WidgetApplication *result = 0 ;
102455
102456   arg1 = (Dali::WidgetApplication *)jarg1;
102457   if (!arg1) {
102458     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
102459     return 0;
102460   }
102461   {
102462     try {
102463       result = (Dali::WidgetApplication *)new Dali::WidgetApplication((Dali::WidgetApplication const &)*arg1);
102464     } catch (std::out_of_range& e) {
102465       {
102466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102467       };
102468     } catch (std::exception& e) {
102469       {
102470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102471       };
102472     } catch (...) {
102473       {
102474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102475       };
102476     }
102477   }
102478   jresult = (void *)result;
102479   return jresult;
102480 }
102481
102482
102483 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_Assign(void * jarg1, void * jarg2) {
102484   void * jresult ;
102485   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
102486   Dali::WidgetApplication *arg2 = 0 ;
102487   Dali::WidgetApplication *result = 0 ;
102488
102489   arg1 = (Dali::WidgetApplication *)jarg1;
102490   arg2 = (Dali::WidgetApplication *)jarg2;
102491   if (!arg2) {
102492     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
102493     return 0;
102494   }
102495   {
102496     try {
102497       result = (Dali::WidgetApplication *) &(arg1)->operator =((Dali::WidgetApplication const &)*arg2);
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_delete_WidgetApplication(void * jarg1) {
102518   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
102519
102520   arg1 = (Dali::WidgetApplication *)jarg1;
102521   {
102522     try {
102523       delete arg1;
102524       if( argWidgetV )
102525       {
102526         // free string data
102527         for( int i=0; i < argWidgetC+1; i++)
102528         {
102529           delete [] argWidgetV[i];
102530         }
102531         delete [] argWidgetV;
102532       }
102533     } catch (std::out_of_range& e) {
102534       {
102535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102536       };
102537     } catch (std::exception& e) {
102538       {
102539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102540       };
102541     } catch (...) {
102542       {
102543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102544       };
102545     }
102546   }
102547 }
102548
102549
102550 typedef Dali::Widget*(SWIGSTDCALL *CSharpCreateWidgetFunction)(const std::string&);
102551 CSharpCreateWidgetFunction _CSharpCreateWidgetFunction = NULL;
102552
102553 static Dali::Widget SWIGSTDCALL WidgetFactoryFunction( const std::string& widgetName )
102554 {
102555   Widget* widget = _CSharpCreateWidgetFunction( widgetName.c_str() );
102556   return *widget;
102557 }
102558
102559 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetApplication_RegisterWidgetCreatingFunction(void * jarg1, char** jarg2, void * jarg3) {
102560   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
102561   std::string *arg2 = 0 ;
102562
102563   arg1 = (Dali::WidgetApplication *)jarg1;
102564   if (!jarg2) {
102565     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102566     return ;
102567   }
102568   std::string arg2_str(*jarg2);
102569   arg2 = &arg2_str;
102570
102571   if(!_CSharpCreateWidgetFunction)
102572   {
102573     _CSharpCreateWidgetFunction = (Dali::Widget*(*)(const std::string&))jarg3;
102574   }
102575
102576   {
102577     try {
102578       (arg1)->RegisterWidgetCreatingFunction((std::string const &)*arg2, WidgetFactoryFunction);
102579     } catch (std::out_of_range& e) {
102580       {
102581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102582       };
102583     } catch (std::exception& e) {
102584       {
102585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102586       };
102587     } catch (...) {
102588       {
102589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102590       };
102591     }
102592   }
102593
102594   //Typemap argout in c++ file.
102595   //This will convert c++ string to c# string
102596   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
102597 }
102598
102599
102600 //for PixelBuffer and ImageLoading
102601
102602 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelBuffer_SWIGUpcast(Dali::Devel::PixelBuffer *jarg1) {
102603     return (Dali::BaseHandle *)jarg1;
102604 }
102605
102606 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_New(unsigned int jarg1, unsigned int jarg2, int jarg3) {
102607   void * jresult ;
102608   unsigned int arg1 ;
102609   unsigned int arg2 ;
102610   Dali::Pixel::Format arg3 ;
102611   Dali::Devel::PixelBuffer result;
102612
102613   arg1 = (unsigned int)jarg1;
102614   arg2 = (unsigned int)jarg2;
102615   arg3 = (Dali::Pixel::Format)jarg3;
102616   {
102617     try {
102618       result = Dali::Devel::PixelBuffer::New(arg1,arg2,arg3);
102619     } catch (std::out_of_range& e) {
102620       {
102621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102622       };
102623     } catch (std::exception& e) {
102624       {
102625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102626       };
102627     } catch (...) {
102628       {
102629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102630       };
102631     }
102632   }
102633   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102634   return jresult;
102635 }
102636
102637
102638 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_0() {
102639   void * jresult ;
102640   Dali::Devel::PixelBuffer *result = 0 ;
102641
102642   {
102643     try {
102644       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer();
102645     } catch (std::out_of_range& e) {
102646       {
102647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102648       };
102649     } catch (std::exception& e) {
102650       {
102651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102652       };
102653     } catch (...) {
102654       {
102655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102656       };
102657     }
102658   }
102659   jresult = (void *)result;
102660   return jresult;
102661 }
102662
102663
102664 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelBuffer(void * jarg1) {
102665   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102666
102667   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102668   {
102669     try {
102670       delete arg1;
102671     } catch (std::out_of_range& e) {
102672       {
102673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102674       };
102675     } catch (std::exception& e) {
102676       {
102677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102678       };
102679     } catch (...) {
102680       {
102681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102682       };
102683     }
102684   }
102685 }
102686
102687
102688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_1(void * jarg1) {
102689   void * jresult ;
102690   Dali::Devel::PixelBuffer *arg1 = 0 ;
102691   Dali::Devel::PixelBuffer *result = 0 ;
102692
102693   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102694   if (!arg1) {
102695     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
102696     return 0;
102697   }
102698   {
102699     try {
102700       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer((Dali::Devel::PixelBuffer const &)*arg1);
102701     } catch (std::out_of_range& e) {
102702       {
102703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102704       };
102705     } catch (std::exception& e) {
102706       {
102707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102708       };
102709     } catch (...) {
102710       {
102711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102712       };
102713     }
102714   }
102715   jresult = (void *)result;
102716   return jresult;
102717 }
102718
102719
102720 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Assign(void * jarg1, void * jarg2) {
102721   void * jresult ;
102722   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102723   Dali::Devel::PixelBuffer *arg2 = 0 ;
102724   Dali::Devel::PixelBuffer *result = 0 ;
102725
102726   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102727   arg2 = (Dali::Devel::PixelBuffer *)jarg2;
102728   if (!arg2) {
102729     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
102730     return 0;
102731   }
102732   {
102733     try {
102734       result = (Dali::Devel::PixelBuffer *) &(arg1)->operator =((Dali::Devel::PixelBuffer const &)*arg2);
102735     } catch (std::out_of_range& e) {
102736       {
102737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102738       };
102739     } catch (std::exception& e) {
102740       {
102741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102742       };
102743     } catch (...) {
102744       {
102745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102746       };
102747     }
102748   }
102749   jresult = (void *)result;
102750   return jresult;
102751 }
102752
102753
102754 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Convert(void * jarg1) {
102755   void * jresult ;
102756   Dali::Devel::PixelBuffer *arg1 = 0 ;
102757   Dali::PixelData result;
102758
102759   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102760   if (!arg1) {
102761     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer & type is null", 0);
102762     return 0;
102763   }
102764   {
102765     try {
102766       result = Dali::Devel::PixelBuffer::Convert(*arg1);
102767     } catch (std::out_of_range& e) {
102768       {
102769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102770       };
102771     } catch (std::exception& e) {
102772       {
102773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102774       };
102775     } catch (...) {
102776       {
102777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102778       };
102779     }
102780   }
102781   jresult = new Dali::PixelData((const Dali::PixelData &)result);
102782   return jresult;
102783 }
102784
102785
102786 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_CreatePixelData(void * jarg1) {
102787   void * jresult ;
102788   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102789   Dali::PixelData result;
102790
102791   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102792   {
102793     try {
102794       result = ((Dali::Devel::PixelBuffer const *)arg1)->CreatePixelData();
102795     } catch (std::out_of_range& e) {
102796       {
102797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102798       };
102799     } catch (std::exception& e) {
102800       {
102801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102802       };
102803     } catch (...) {
102804       {
102805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102806       };
102807     }
102808   }
102809   jresult = new Dali::PixelData((const Dali::PixelData &)result);
102810   return jresult;
102811 }
102812
102813
102814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_GetBuffer(void * jarg1) {
102815   void * jresult ;
102816   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102817   unsigned char *result = 0 ;
102818
102819   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102820   {
102821     try {
102822       result = (unsigned char *)(arg1)->GetBuffer();
102823     } catch (std::out_of_range& e) {
102824       {
102825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102826       };
102827     } catch (std::exception& e) {
102828       {
102829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102830       };
102831     } catch (...) {
102832       {
102833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102834       };
102835     }
102836   }
102837   jresult = (void *)result;
102838   return jresult;
102839 }
102840
102841
102842 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetWidth(void * jarg1) {
102843   unsigned int jresult ;
102844   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102845   unsigned int result;
102846
102847   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102848   {
102849     try {
102850       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetWidth();
102851     } catch (std::out_of_range& e) {
102852       {
102853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102854       };
102855     } catch (std::exception& e) {
102856       {
102857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102858       };
102859     } catch (...) {
102860       {
102861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102862       };
102863     }
102864   }
102865   jresult = result;
102866   return jresult;
102867 }
102868
102869
102870 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetHeight(void * jarg1) {
102871   unsigned int jresult ;
102872   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102873   unsigned int result;
102874
102875   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102876   {
102877     try {
102878       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetHeight();
102879     } catch (std::out_of_range& e) {
102880       {
102881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102882       };
102883     } catch (std::exception& e) {
102884       {
102885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102886       };
102887     } catch (...) {
102888       {
102889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102890       };
102891     }
102892   }
102893   jresult = result;
102894   return jresult;
102895 }
102896
102897
102898 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetPixelFormat(void * jarg1) {
102899   int jresult ;
102900   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102901   Dali::Pixel::Format result;
102902
102903   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102904   {
102905     try {
102906       result = (Dali::Pixel::Format)((Dali::Devel::PixelBuffer const *)arg1)->GetPixelFormat();
102907     } catch (std::out_of_range& e) {
102908       {
102909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102910       };
102911     } catch (std::exception& e) {
102912       {
102913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102914       };
102915     } catch (...) {
102916       {
102917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102918       };
102919     }
102920   }
102921   jresult = (int)result;
102922   return jresult;
102923 }
102924
102925
102926 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_0(void * jarg1, void * jarg2, float jarg3, unsigned int jarg4) {
102927   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102928   Dali::Devel::PixelBuffer arg2 ;
102929   float arg3 ;
102930   bool arg4 ;
102931   Dali::Devel::PixelBuffer *argp2 ;
102932
102933   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102934   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
102935   if (!argp2) {
102936     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
102937     return ;
102938   }
102939   arg2 = *argp2;
102940   arg3 = (float)jarg3;
102941   arg4 = jarg4 ? true : false;
102942   {
102943     try {
102944       (arg1)->ApplyMask(arg2,arg3,arg4);
102945     } catch (std::out_of_range& e) {
102946       {
102947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102948       };
102949     } catch (std::exception& e) {
102950       {
102951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102952       };
102953     } catch (...) {
102954       {
102955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102956       };
102957     }
102958   }
102959 }
102960
102961
102962 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
102963   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102964   Dali::Devel::PixelBuffer arg2 ;
102965   float arg3 ;
102966   Dali::Devel::PixelBuffer *argp2 ;
102967
102968   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102969   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
102970   if (!argp2) {
102971     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
102972     return ;
102973   }
102974   arg2 = *argp2;
102975   arg3 = (float)jarg3;
102976   {
102977     try {
102978       (arg1)->ApplyMask(arg2,arg3);
102979     } catch (std::out_of_range& e) {
102980       {
102981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102982       };
102983     } catch (std::exception& e) {
102984       {
102985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102986       };
102987     } catch (...) {
102988       {
102989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102990       };
102991     }
102992   }
102993 }
102994
102995
102996 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_2(void * jarg1, void * jarg2) {
102997   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102998   Dali::Devel::PixelBuffer arg2 ;
102999   Dali::Devel::PixelBuffer *argp2 ;
103000
103001   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
103002   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
103003   if (!argp2) {
103004     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
103005     return ;
103006   }
103007   arg2 = *argp2;
103008   {
103009     try {
103010       (arg1)->ApplyMask(arg2);
103011     } catch (std::out_of_range& e) {
103012       {
103013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103014       };
103015     } catch (std::exception& e) {
103016       {
103017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103018       };
103019     } catch (...) {
103020       {
103021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103022       };
103023     }
103024   }
103025 }
103026
103027
103028 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyGaussianBlur(void * jarg1, float jarg2) {
103029   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
103030   float arg2 ;
103031
103032   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
103033   arg2 = (float)jarg2;
103034   {
103035     try {
103036       (arg1)->ApplyGaussianBlur(arg2);
103037     } catch (std::out_of_range& e) {
103038       {
103039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103040       };
103041     } catch (std::exception& e) {
103042       {
103043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103044       };
103045     } catch (...) {
103046       {
103047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103048       };
103049     }
103050   }
103051 }
103052
103053
103054 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Crop(void * jarg1, unsigned short jarg2, unsigned short jarg3, unsigned short jarg4, unsigned short jarg5) {
103055   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
103056   uint16_t arg2 ;
103057   uint16_t arg3 ;
103058   uint16_t arg4 ;
103059   uint16_t arg5 ;
103060
103061   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
103062   arg2 = (uint16_t)jarg2;
103063   arg3 = (uint16_t)jarg3;
103064   arg4 = (uint16_t)jarg4;
103065   arg5 = (uint16_t)jarg5;
103066   {
103067     try {
103068       (arg1)->Crop(arg2,arg3,arg4,arg5);
103069     } catch (std::out_of_range& e) {
103070       {
103071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103072       };
103073     } catch (std::exception& e) {
103074       {
103075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103076       };
103077     } catch (...) {
103078       {
103079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103080       };
103081     }
103082   }
103083 }
103084
103085
103086 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Resize(void * jarg1, unsigned short jarg2, unsigned short jarg3) {
103087   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
103088   uint16_t arg2 ;
103089   uint16_t arg3 ;
103090
103091   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
103092   arg2 = (uint16_t)jarg2;
103093   arg3 = (uint16_t)jarg3;
103094   {
103095     try {
103096       (arg1)->Resize(arg2,arg3);
103097     } catch (std::out_of_range& e) {
103098       {
103099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103100       };
103101     } catch (std::exception& e) {
103102       {
103103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103104       };
103105     } catch (...) {
103106       {
103107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103108       };
103109     }
103110   }
103111 }
103112
103113
103114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_2(void * jarg1) {
103115   void * jresult ;
103116   Dali::Internal::Adaptor::PixelBuffer *arg1 = (Dali::Internal::Adaptor::PixelBuffer *) 0 ;
103117   Dali::Devel::PixelBuffer *result = 0 ;
103118
103119   arg1 = (Dali::Internal::Adaptor::PixelBuffer *)jarg1;
103120   {
103121     try {
103122       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer(arg1);
103123     } catch (std::out_of_range& e) {
103124       {
103125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103126       };
103127     } catch (std::exception& e) {
103128       {
103129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103130       };
103131     } catch (...) {
103132       {
103133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103134       };
103135     }
103136   }
103137   jresult = (void *)result;
103138   return jresult;
103139 }
103140
103141
103142 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
103143   void * jresult ;
103144   std::string *arg1 = 0 ;
103145   Dali::ImageDimensions arg2 ;
103146   Dali::FittingMode::Type arg3 ;
103147   Dali::SamplingMode::Type arg4 ;
103148   bool arg5 ;
103149   Dali::ImageDimensions *argp2 ;
103150   Dali::Devel::PixelBuffer result;
103151
103152   if (!jarg1) {
103153     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103154     return 0;
103155   }
103156   std::string arg1_str(jarg1);
103157   arg1 = &arg1_str;
103158   argp2 = (Dali::ImageDimensions *)jarg2;
103159   if (!argp2) {
103160     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103161     return 0;
103162   }
103163   arg2 = *argp2;
103164   arg3 = (Dali::FittingMode::Type)jarg3;
103165   arg4 = (Dali::SamplingMode::Type)jarg4;
103166   arg5 = jarg5 ? true : false;
103167   {
103168     try {
103169       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4,arg5);
103170     } catch (std::out_of_range& e) {
103171       {
103172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103173       };
103174     } catch (std::exception& e) {
103175       {
103176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103177       };
103178     } catch (...) {
103179       {
103180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103181       };
103182     }
103183   }
103184   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103185
103186   return jresult;
103187 }
103188
103189
103190 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
103191   void * jresult ;
103192   std::string *arg1 = 0 ;
103193   Dali::ImageDimensions arg2 ;
103194   Dali::FittingMode::Type arg3 ;
103195   Dali::SamplingMode::Type arg4 ;
103196   Dali::ImageDimensions *argp2 ;
103197   Dali::Devel::PixelBuffer result;
103198
103199   if (!jarg1) {
103200     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103201     return 0;
103202   }
103203   std::string arg1_str(jarg1);
103204   arg1 = &arg1_str;
103205   argp2 = (Dali::ImageDimensions *)jarg2;
103206   if (!argp2) {
103207     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103208     return 0;
103209   }
103210   arg2 = *argp2;
103211   arg3 = (Dali::FittingMode::Type)jarg3;
103212   arg4 = (Dali::SamplingMode::Type)jarg4;
103213   {
103214     try {
103215       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4);
103216     } catch (std::out_of_range& e) {
103217       {
103218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103219       };
103220     } catch (std::exception& e) {
103221       {
103222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103223       };
103224     } catch (...) {
103225       {
103226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103227       };
103228     }
103229   }
103230   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103231
103232   return jresult;
103233 }
103234
103235
103236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
103237   void * jresult ;
103238   std::string *arg1 = 0 ;
103239   Dali::ImageDimensions arg2 ;
103240   Dali::FittingMode::Type arg3 ;
103241   Dali::ImageDimensions *argp2 ;
103242   Dali::Devel::PixelBuffer result;
103243
103244   if (!jarg1) {
103245     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103246     return 0;
103247   }
103248   std::string arg1_str(jarg1);
103249   arg1 = &arg1_str;
103250   argp2 = (Dali::ImageDimensions *)jarg2;
103251   if (!argp2) {
103252     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103253     return 0;
103254   }
103255   arg2 = *argp2;
103256   arg3 = (Dali::FittingMode::Type)jarg3;
103257   {
103258     try {
103259       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3);
103260     } catch (std::out_of_range& e) {
103261       {
103262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103263       };
103264     } catch (std::exception& e) {
103265       {
103266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103267       };
103268     } catch (...) {
103269       {
103270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103271       };
103272     }
103273   }
103274   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103275
103276   return jresult;
103277 }
103278
103279
103280 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_3(char * jarg1, void * jarg2) {
103281   void * jresult ;
103282   std::string *arg1 = 0 ;
103283   Dali::ImageDimensions arg2 ;
103284   Dali::ImageDimensions *argp2 ;
103285   Dali::Devel::PixelBuffer result;
103286
103287   if (!jarg1) {
103288     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103289     return 0;
103290   }
103291   std::string arg1_str(jarg1);
103292   arg1 = &arg1_str;
103293   argp2 = (Dali::ImageDimensions *)jarg2;
103294   if (!argp2) {
103295     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103296     return 0;
103297   }
103298   arg2 = *argp2;
103299   {
103300     try {
103301       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2);
103302     } catch (std::out_of_range& e) {
103303       {
103304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103305       };
103306     } catch (std::exception& e) {
103307       {
103308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103309       };
103310     } catch (...) {
103311       {
103312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103313       };
103314     }
103315   }
103316   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103317
103318   return jresult;
103319 }
103320
103321
103322 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_4(char * jarg1) {
103323   void * jresult ;
103324   std::string *arg1 = 0 ;
103325   Dali::Devel::PixelBuffer result;
103326
103327   if (!jarg1) {
103328     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103329     return 0;
103330   }
103331   std::string arg1_str(jarg1);
103332   arg1 = &arg1_str;
103333   {
103334     try {
103335       result = Dali::LoadImageFromFile((std::string const &)*arg1);
103336     } catch (std::out_of_range& e) {
103337       {
103338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103339       };
103340     } catch (std::exception& e) {
103341       {
103342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103343       };
103344     } catch (...) {
103345       {
103346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103347       };
103348     }
103349   }
103350   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103351
103352   return jresult;
103353 }
103354
103355
103356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
103357   void * jresult ;
103358   std::string *arg1 = 0 ;
103359   Dali::ImageDimensions arg2 ;
103360   Dali::FittingMode::Type arg3 ;
103361   Dali::SamplingMode::Type arg4 ;
103362   bool arg5 ;
103363   Dali::ImageDimensions *argp2 ;
103364   Dali::ImageDimensions result;
103365
103366   if (!jarg1) {
103367     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103368     return 0;
103369   }
103370   std::string arg1_str(jarg1);
103371   arg1 = &arg1_str;
103372   argp2 = (Dali::ImageDimensions *)jarg2;
103373   if (!argp2) {
103374     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103375     return 0;
103376   }
103377   arg2 = *argp2;
103378   arg3 = (Dali::FittingMode::Type)jarg3;
103379   arg4 = (Dali::SamplingMode::Type)jarg4;
103380   arg5 = jarg5 ? true : false;
103381   {
103382     try {
103383       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4,arg5);
103384     } catch (std::out_of_range& e) {
103385       {
103386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103387       };
103388     } catch (std::exception& e) {
103389       {
103390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103391       };
103392     } catch (...) {
103393       {
103394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103395       };
103396     }
103397   }
103398   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
103399
103400   return jresult;
103401 }
103402
103403
103404 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
103405   void * jresult ;
103406   std::string *arg1 = 0 ;
103407   Dali::ImageDimensions arg2 ;
103408   Dali::FittingMode::Type arg3 ;
103409   Dali::SamplingMode::Type arg4 ;
103410   Dali::ImageDimensions *argp2 ;
103411   Dali::ImageDimensions result;
103412
103413   if (!jarg1) {
103414     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103415     return 0;
103416   }
103417   std::string arg1_str(jarg1);
103418   arg1 = &arg1_str;
103419   argp2 = (Dali::ImageDimensions *)jarg2;
103420   if (!argp2) {
103421     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103422     return 0;
103423   }
103424   arg2 = *argp2;
103425   arg3 = (Dali::FittingMode::Type)jarg3;
103426   arg4 = (Dali::SamplingMode::Type)jarg4;
103427   {
103428     try {
103429       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4);
103430     } catch (std::out_of_range& e) {
103431       {
103432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103433       };
103434     } catch (std::exception& e) {
103435       {
103436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103437       };
103438     } catch (...) {
103439       {
103440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103441       };
103442     }
103443   }
103444   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
103445
103446   return jresult;
103447 }
103448
103449
103450 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
103451   void * jresult ;
103452   std::string *arg1 = 0 ;
103453   Dali::ImageDimensions arg2 ;
103454   Dali::FittingMode::Type arg3 ;
103455   Dali::ImageDimensions *argp2 ;
103456   Dali::ImageDimensions result;
103457
103458   if (!jarg1) {
103459     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103460     return 0;
103461   }
103462   std::string arg1_str(jarg1);
103463   arg1 = &arg1_str;
103464   argp2 = (Dali::ImageDimensions *)jarg2;
103465   if (!argp2) {
103466     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103467     return 0;
103468   }
103469   arg2 = *argp2;
103470   arg3 = (Dali::FittingMode::Type)jarg3;
103471   {
103472     try {
103473       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3);
103474     } catch (std::out_of_range& e) {
103475       {
103476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103477       };
103478     } catch (std::exception& e) {
103479       {
103480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103481       };
103482     } catch (...) {
103483       {
103484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103485       };
103486     }
103487   }
103488   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
103489
103490   return jresult;
103491 }
103492
103493
103494 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_3(char * jarg1, void * jarg2) {
103495   void * jresult ;
103496   std::string *arg1 = 0 ;
103497   Dali::ImageDimensions arg2 ;
103498   Dali::ImageDimensions *argp2 ;
103499   Dali::ImageDimensions result;
103500
103501   if (!jarg1) {
103502     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103503     return 0;
103504   }
103505   std::string arg1_str(jarg1);
103506   arg1 = &arg1_str;
103507   argp2 = (Dali::ImageDimensions *)jarg2;
103508   if (!argp2) {
103509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103510     return 0;
103511   }
103512   arg2 = *argp2;
103513   {
103514     try {
103515       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2);
103516     } catch (std::out_of_range& e) {
103517       {
103518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103519       };
103520     } catch (std::exception& e) {
103521       {
103522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103523       };
103524     } catch (...) {
103525       {
103526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103527       };
103528     }
103529   }
103530   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
103531
103532   return jresult;
103533 }
103534
103535
103536 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_4(char * jarg1) {
103537   void * jresult ;
103538   std::string *arg1 = 0 ;
103539   Dali::ImageDimensions result;
103540
103541   if (!jarg1) {
103542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103543     return 0;
103544   }
103545   std::string arg1_str(jarg1);
103546   arg1 = &arg1_str;
103547   {
103548     try {
103549       result = Dali::GetClosestImageSize((std::string const &)*arg1);
103550     } catch (std::out_of_range& e) {
103551       {
103552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103553       };
103554     } catch (std::exception& e) {
103555       {
103556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103557       };
103558     } catch (...) {
103559       {
103560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103561       };
103562     }
103563   }
103564   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
103565
103566   return jresult;
103567 }
103568
103569
103570 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
103571   void * jresult ;
103572   std::string *arg1 = 0 ;
103573   Dali::ImageDimensions arg2 ;
103574   Dali::FittingMode::Type arg3 ;
103575   Dali::SamplingMode::Type arg4 ;
103576   bool arg5 ;
103577   Dali::ImageDimensions *argp2 ;
103578   Dali::Devel::PixelBuffer result;
103579
103580   if (!jarg1) {
103581     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103582     return 0;
103583   }
103584   std::string arg1_str(jarg1);
103585   arg1 = &arg1_str;
103586   argp2 = (Dali::ImageDimensions *)jarg2;
103587   if (!argp2) {
103588     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103589     return 0;
103590   }
103591   arg2 = *argp2;
103592   arg3 = (Dali::FittingMode::Type)jarg3;
103593   arg4 = (Dali::SamplingMode::Type)jarg4;
103594   arg5 = jarg5 ? true : false;
103595   {
103596     try {
103597       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4,arg5);
103598     } catch (std::out_of_range& e) {
103599       {
103600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103601       };
103602     } catch (std::exception& e) {
103603       {
103604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103605       };
103606     } catch (...) {
103607       {
103608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103609       };
103610     }
103611   }
103612   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103613
103614   return jresult;
103615 }
103616
103617
103618 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
103619   void * jresult ;
103620   std::string *arg1 = 0 ;
103621   Dali::ImageDimensions arg2 ;
103622   Dali::FittingMode::Type arg3 ;
103623   Dali::SamplingMode::Type arg4 ;
103624   Dali::ImageDimensions *argp2 ;
103625   Dali::Devel::PixelBuffer result;
103626
103627   if (!jarg1) {
103628     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103629     return 0;
103630   }
103631   std::string arg1_str(jarg1);
103632   arg1 = &arg1_str;
103633   argp2 = (Dali::ImageDimensions *)jarg2;
103634   if (!argp2) {
103635     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103636     return 0;
103637   }
103638   arg2 = *argp2;
103639   arg3 = (Dali::FittingMode::Type)jarg3;
103640   arg4 = (Dali::SamplingMode::Type)jarg4;
103641   {
103642     try {
103643       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4);
103644     } catch (std::out_of_range& e) {
103645       {
103646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103647       };
103648     } catch (std::exception& e) {
103649       {
103650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103651       };
103652     } catch (...) {
103653       {
103654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103655       };
103656     }
103657   }
103658   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103659
103660   return jresult;
103661 }
103662
103663
103664 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
103665   void * jresult ;
103666   std::string *arg1 = 0 ;
103667   Dali::ImageDimensions arg2 ;
103668   Dali::FittingMode::Type arg3 ;
103669   Dali::ImageDimensions *argp2 ;
103670   Dali::Devel::PixelBuffer result;
103671
103672   if (!jarg1) {
103673     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103674     return 0;
103675   }
103676   std::string arg1_str(jarg1);
103677   arg1 = &arg1_str;
103678   argp2 = (Dali::ImageDimensions *)jarg2;
103679   if (!argp2) {
103680     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103681     return 0;
103682   }
103683   arg2 = *argp2;
103684   arg3 = (Dali::FittingMode::Type)jarg3;
103685   {
103686     try {
103687       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3);
103688     } catch (std::out_of_range& e) {
103689       {
103690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103691       };
103692     } catch (std::exception& e) {
103693       {
103694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103695       };
103696     } catch (...) {
103697       {
103698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103699       };
103700     }
103701   }
103702   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103703
103704   return jresult;
103705 }
103706
103707
103708 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_3(char * jarg1, void * jarg2) {
103709   void * jresult ;
103710   std::string *arg1 = 0 ;
103711   Dali::ImageDimensions arg2 ;
103712   Dali::ImageDimensions *argp2 ;
103713   Dali::Devel::PixelBuffer result;
103714
103715   if (!jarg1) {
103716     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103717     return 0;
103718   }
103719   std::string arg1_str(jarg1);
103720   arg1 = &arg1_str;
103721   argp2 = (Dali::ImageDimensions *)jarg2;
103722   if (!argp2) {
103723     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103724     return 0;
103725   }
103726   arg2 = *argp2;
103727   {
103728     try {
103729       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2);
103730     } catch (std::out_of_range& e) {
103731       {
103732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103733       };
103734     } catch (std::exception& e) {
103735       {
103736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103737       };
103738     } catch (...) {
103739       {
103740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103741       };
103742     }
103743   }
103744   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103745
103746   return jresult;
103747 }
103748
103749
103750 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_4(char * jarg1) {
103751   void * jresult ;
103752   std::string *arg1 = 0 ;
103753   Dali::Devel::PixelBuffer result;
103754
103755   if (!jarg1) {
103756     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103757     return 0;
103758   }
103759   std::string arg1_str(jarg1);
103760   arg1 = &arg1_str;
103761   {
103762     try {
103763       result = Dali::DownloadImageSynchronously((std::string const &)*arg1);
103764     } catch (std::out_of_range& e) {
103765       {
103766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103767       };
103768     } catch (std::exception& e) {
103769       {
103770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103771       };
103772     } catch (...) {
103773       {
103774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103775       };
103776     }
103777   }
103778   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103779
103780   return jresult;
103781 }
103782
103783
103784 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetMaxTextureSize(unsigned int jarg1) {
103785   unsigned int arg1 ;
103786
103787   arg1 = (unsigned int)jarg1;
103788   {
103789     try {
103790       Dali::SetMaxTextureSize(arg1);
103791     } catch (std::out_of_range& e) {
103792       {
103793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103794       };
103795     } catch (std::exception& e) {
103796       {
103797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103798       };
103799     } catch (...) {
103800       {
103801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103802       };
103803     }
103804   }
103805 }
103806
103807
103808 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetMaxTextureSize() {
103809   unsigned int jresult ;
103810   unsigned int result;
103811
103812   {
103813     try {
103814       result = (unsigned int)Dali::GetMaxTextureSize();
103815     } catch (std::out_of_range& e) {
103816       {
103817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103818       };
103819     } catch (std::exception& e) {
103820       {
103821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103822       };
103823     } catch (...) {
103824       {
103825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103826       };
103827     }
103828   }
103829   jresult = result;
103830   return jresult;
103831 }
103832
103833
103834 #ifdef __cplusplus
103835 }
103836 #endif
103837