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   {
64385     try {
64386       if(darg) {
64387         (darg)->OnStageConnection(arg2);
64388       }
64389     } catch (std::out_of_range& e) {
64390       {
64391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64392       };
64393     } catch (std::exception& e) {
64394       {
64395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64396       };
64397     } catch (Dali::DaliException e) {
64398       {
64399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64400       };
64401     } catch (...) {
64402       {
64403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64404       };
64405     }
64406   }
64407
64408 }
64409
64410
64411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnectionSwigExplicitViewImpl(void * jarg1, int jarg2) {
64412   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64413   int arg2 ;
64414   SwigDirector_ViewImpl *darg = 0;
64415
64416   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64417   arg2 = (int)jarg2;
64418   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64419   {
64420     try {
64421       if(darg) {
64422         (darg)->OnStageConnectionSwigPublic(arg2);
64423       }
64424     } catch (std::out_of_range& e) {
64425       {
64426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64427       };
64428     } catch (std::exception& e) {
64429       {
64430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64431       };
64432     } catch (Dali::DaliException e) {
64433       {
64434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64435       };
64436     } catch (...) {
64437       {
64438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64439       };
64440     }
64441   }
64442
64443 }
64444
64445
64446 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnection(void * jarg1) {
64447   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64448   SwigDirector_ViewImpl *darg = 0;
64449
64450   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64451   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64452   {
64453     try {
64454       if(darg) {
64455         (darg)->OnStageDisconnection();
64456       }
64457     } catch (std::out_of_range& e) {
64458       {
64459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64460       };
64461     } catch (std::exception& e) {
64462       {
64463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64464       };
64465     } catch (Dali::DaliException e) {
64466       {
64467         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64468       };
64469     } catch (...) {
64470       {
64471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64472       };
64473     }
64474   }
64475
64476 }
64477
64478
64479 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnectionSwigExplicitViewImpl(void * jarg1) {
64480   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64481   SwigDirector_ViewImpl *darg = 0;
64482
64483   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64484   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64485   {
64486     try {
64487       if(darg) {
64488         (darg)->OnStageDisconnectionSwigPublic();
64489       }
64490     } catch (std::out_of_range& e) {
64491       {
64492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64493       };
64494     } catch (std::exception& e) {
64495       {
64496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64497       };
64498     } catch (Dali::DaliException e) {
64499       {
64500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64501       };
64502     } catch (...) {
64503       {
64504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64505       };
64506     }
64507   }
64508
64509 }
64510
64511
64512 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAdd(void * jarg1, void * jarg2) {
64513   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64514   Dali::Actor *arg2 = 0 ;
64515   SwigDirector_ViewImpl *darg = 0;
64516
64517   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64518   arg2 = (Dali::Actor *)jarg2;
64519   if (!arg2) {
64520     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
64521     return ;
64522   }
64523   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64524   {
64525     try {
64526       if(darg) {
64527         (darg)->OnChildAdd(*arg2);
64528       }
64529     } catch (std::out_of_range& e) {
64530       {
64531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64532       };
64533     } catch (std::exception& e) {
64534       {
64535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64536       };
64537     } catch (Dali::DaliException e) {
64538       {
64539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64540       };
64541     } catch (...) {
64542       {
64543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64544       };
64545     }
64546   }
64547
64548 }
64549
64550
64551 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64552   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64553   Dali::Actor *arg2 = 0 ;
64554   SwigDirector_ViewImpl *darg = 0;
64555
64556   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64557   arg2 = (Dali::Actor *)jarg2;
64558   if (!arg2) {
64559     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
64560     return ;
64561   }
64562   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64563   {
64564     try {
64565       if(darg) {
64566           (darg)->OnChildAddSwigPublic(*arg2);
64567       }
64568     } catch (std::out_of_range& e) {
64569       {
64570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64571       };
64572     } catch (std::exception& e) {
64573       {
64574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64575       };
64576     } catch (Dali::DaliException e) {
64577       {
64578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64579       };
64580     } catch (...) {
64581       {
64582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64583       };
64584     }
64585   }
64586
64587 }
64588
64589
64590 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemove(void * jarg1, void * jarg2) {
64591   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64592   Dali::Actor *arg2 = 0 ;
64593   SwigDirector_ViewImpl *darg = 0;
64594
64595   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64596   arg2 = (Dali::Actor *)jarg2;
64597   if (!arg2) {
64598     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
64599     return ;
64600   }
64601   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64602   {
64603     try {
64604       if(darg) {
64605         (darg)->OnChildRemove(*arg2);
64606       }
64607     } catch (std::out_of_range& e) {
64608       {
64609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64610       };
64611     } catch (std::exception& e) {
64612       {
64613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64614       };
64615     } catch (Dali::DaliException e) {
64616       {
64617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64618       };
64619     } catch (...) {
64620       {
64621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64622       };
64623     }
64624   }
64625
64626 }
64627
64628
64629 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64630   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64631   Dali::Actor *arg2 = 0 ;
64632   SwigDirector_ViewImpl *darg = 0;
64633
64634   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64635   arg2 = (Dali::Actor *)jarg2;
64636   if (!arg2) {
64637     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
64638     return ;
64639   }
64640   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64641   {
64642     try {
64643       if(darg) {
64644         (darg)->OnChildRemoveSwigPublic(*arg2);
64645       }
64646     } catch (std::out_of_range& e) {
64647       {
64648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64649       };
64650     } catch (std::exception& e) {
64651       {
64652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64653       };
64654     } catch (Dali::DaliException e) {
64655       {
64656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64657       };
64658     } catch (...) {
64659       {
64660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64661       };
64662     }
64663   }
64664
64665 }
64666
64667
64668 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
64669   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64670   Dali::Property::Index arg2 ;
64671   Dali::Property::Value arg3 ;
64672   Dali::Property::Value *argp3 ;
64673   SwigDirector_ViewImpl *darg = 0;
64674
64675   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64676   arg2 = (Dali::Property::Index)jarg2;
64677   argp3 = (Dali::Property::Value *)jarg3;
64678   if (!argp3) {
64679     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
64680     return ;
64681   }
64682   arg3 = *argp3;
64683   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64684   if (!darg) {
64685     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64686     return;
64687   }
64688   {
64689     try {
64690       (darg)->OnPropertySet(arg2,arg3);
64691     } catch (std::out_of_range& e) {
64692       {
64693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64694       };
64695     } catch (std::exception& e) {
64696       {
64697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64698       };
64699     } catch (Dali::DaliException e) {
64700       {
64701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64702       };
64703     } catch (...) {
64704       {
64705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64706       };
64707     }
64708   }
64709
64710 }
64711
64712
64713 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySetSwigExplicitViewImpl(void * jarg1, int jarg2, void * jarg3) {
64714   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64715   Dali::Property::Index arg2 ;
64716   Dali::Property::Value arg3 ;
64717   Dali::Property::Value *argp3 ;
64718   SwigDirector_ViewImpl *darg = 0;
64719
64720   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64721   arg2 = (Dali::Property::Index)jarg2;
64722   argp3 = (Dali::Property::Value *)jarg3;
64723   if (!argp3) {
64724     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
64725     return ;
64726   }
64727   arg3 = *argp3;
64728   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64729   if (!darg) {
64730     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64731     return;
64732   }
64733   {
64734     try {
64735       (darg)->OnPropertySetSwigPublic(arg2,arg3);
64736     } catch (std::out_of_range& e) {
64737       {
64738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64739       };
64740     } catch (std::exception& e) {
64741       {
64742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64743       };
64744     } catch (Dali::DaliException e) {
64745       {
64746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64747       };
64748     } catch (...) {
64749       {
64750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64751       };
64752     }
64753   }
64754
64755 }
64756
64757
64758 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSet(void * jarg1, void * jarg2) {
64759   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64760   Dali::Vector3 *arg2 = 0 ;
64761   SwigDirector_ViewImpl *darg = 0;
64762
64763   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64764   arg2 = (Dali::Vector3 *)jarg2;
64765   if (!arg2) {
64766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64767     return ;
64768   }
64769   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64770   if (!darg) {
64771     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64772     return;
64773   }
64774   {
64775     try {
64776       (darg)->OnSizeSet((Dali::Vector3 const &)*arg2);
64777     } catch (std::out_of_range& e) {
64778       {
64779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64780       };
64781     } catch (std::exception& e) {
64782       {
64783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64784       };
64785     } catch (Dali::DaliException e) {
64786       {
64787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64788       };
64789     } catch (...) {
64790       {
64791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64792       };
64793     }
64794   }
64795
64796 }
64797
64798
64799 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSetSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64800   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64801   Dali::Vector3 *arg2 = 0 ;
64802   SwigDirector_ViewImpl *darg = 0;
64803
64804   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64805   arg2 = (Dali::Vector3 *)jarg2;
64806   if (!arg2) {
64807     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64808     return ;
64809   }
64810   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64811   if (!darg) {
64812     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64813     return;
64814   }
64815   {
64816     try {
64817       (darg)->OnSizeSetSwigPublic((Dali::Vector3 const &)*arg2);
64818     } catch (std::out_of_range& e) {
64819       {
64820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64821       };
64822     } catch (std::exception& e) {
64823       {
64824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64825       };
64826     } catch (Dali::DaliException e) {
64827       {
64828         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64829       };
64830     } catch (...) {
64831       {
64832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64833       };
64834     }
64835   }
64836
64837 }
64838
64839
64840 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
64841   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64842   Dali::Animation *arg2 = 0 ;
64843   Dali::Vector3 *arg3 = 0 ;
64844   SwigDirector_ViewImpl *darg = 0;
64845
64846   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64847   arg2 = (Dali::Animation *)jarg2;
64848   if (!arg2) {
64849     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
64850     return ;
64851   }
64852   arg3 = (Dali::Vector3 *)jarg3;
64853   if (!arg3) {
64854     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64855     return ;
64856   }
64857   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64858   if (!darg) {
64859     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64860     return;
64861   }
64862   {
64863     try {
64864       (darg)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
64865     } catch (std::out_of_range& e) {
64866       {
64867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64868       };
64869     } catch (std::exception& e) {
64870       {
64871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64872       };
64873     } catch (Dali::DaliException e) {
64874       {
64875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64876       };
64877     } catch (...) {
64878       {
64879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64880       };
64881     }
64882   }
64883
64884 }
64885
64886
64887 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimationSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
64888   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64889   Dali::Animation *arg2 = 0 ;
64890   Dali::Vector3 *arg3 = 0 ;
64891   SwigDirector_ViewImpl *darg = 0;
64892
64893   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64894   arg2 = (Dali::Animation *)jarg2;
64895   if (!arg2) {
64896     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
64897     return ;
64898   }
64899   arg3 = (Dali::Vector3 *)jarg3;
64900   if (!arg3) {
64901     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64902     return ;
64903   }
64904   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64905   if (!darg) {
64906     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64907     return;
64908   }
64909   {
64910     try {
64911       (darg)->OnSizeAnimationSwigPublic(*arg2,(Dali::Vector3 const &)*arg3);
64912     } catch (std::out_of_range& e) {
64913       {
64914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64915       };
64916     } catch (std::exception& e) {
64917       {
64918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64919       };
64920     } catch (Dali::DaliException e) {
64921       {
64922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64923       };
64924     } catch (...) {
64925       {
64926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64927       };
64928     }
64929   }
64930
64931 }
64932
64933
64934 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEvent(void * jarg1, void * jarg2) {
64935   unsigned int jresult ;
64936   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64937   Dali::TouchEvent *arg2 = 0 ;
64938   SwigDirector_ViewImpl *darg = 0;
64939   bool result;
64940
64941   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64942   arg2 = (Dali::TouchEvent *)jarg2;
64943   if (!arg2) {
64944     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
64945     return 0;
64946   }
64947   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64948   if (!darg) {
64949     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64950     return 0;
64951   }
64952   {
64953     try {
64954       result = (bool)(darg)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
64955     } catch (std::out_of_range& e) {
64956       {
64957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64958       };
64959     } catch (std::exception& e) {
64960       {
64961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64962       };
64963     } catch (Dali::DaliException e) {
64964       {
64965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64966       };
64967     } catch (...) {
64968       {
64969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64970       };
64971     }
64972   }
64973
64974   jresult = result;
64975   return jresult;
64976 }
64977
64978
64979 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64980   unsigned int jresult ;
64981   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64982   Dali::TouchEvent *arg2 = 0 ;
64983   SwigDirector_ViewImpl *darg = 0;
64984   bool result;
64985
64986   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64987   arg2 = (Dali::TouchEvent *)jarg2;
64988   if (!arg2) {
64989     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
64990     return 0;
64991   }
64992   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64993   if (!darg) {
64994     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64995     return 0;
64996   }
64997   {
64998     try {
64999       result = (bool)(darg)->OnTouchEventSwigPublic((Dali::TouchEvent const &)*arg2);
65000     } catch (std::out_of_range& e) {
65001       {
65002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65003       };
65004     } catch (std::exception& e) {
65005       {
65006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65007       };
65008     } catch (Dali::DaliException e) {
65009       {
65010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65011       };
65012     } catch (...) {
65013       {
65014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65015       };
65016     }
65017   }
65018
65019   jresult = result;
65020   return jresult;
65021 }
65022
65023
65024 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEvent(void * jarg1, void * jarg2) {
65025   unsigned int jresult ;
65026   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65027   Dali::HoverEvent *arg2 = 0 ;
65028   SwigDirector_ViewImpl *darg = 0;
65029   bool result;
65030
65031   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65032   arg2 = (Dali::HoverEvent *)jarg2;
65033   if (!arg2) {
65034     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
65035     return 0;
65036   }
65037   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65038   if (!darg) {
65039     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65040     return 0;
65041   }
65042   {
65043     try {
65044       result = (bool)(darg)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
65045     } catch (std::out_of_range& e) {
65046       {
65047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65048       };
65049     } catch (std::exception& e) {
65050       {
65051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65052       };
65053     } catch (Dali::DaliException e) {
65054       {
65055         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65056       };
65057     } catch (...) {
65058       {
65059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65060       };
65061     }
65062   }
65063
65064   jresult = result;
65065   return jresult;
65066 }
65067
65068
65069 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
65070   unsigned int jresult ;
65071   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65072   Dali::HoverEvent *arg2 = 0 ;
65073   SwigDirector_ViewImpl *darg = 0;
65074   bool result;
65075
65076   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65077   arg2 = (Dali::HoverEvent *)jarg2;
65078   if (!arg2) {
65079     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
65080     return 0;
65081   }
65082   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65083   if (!darg) {
65084     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65085     return 0;
65086   }
65087   {
65088     try {
65089       result = (bool)(darg)->OnHoverEventSwigPublic((Dali::HoverEvent const &)*arg2);
65090     } catch (std::out_of_range& e) {
65091       {
65092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65093       };
65094     } catch (std::exception& e) {
65095       {
65096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65097       };
65098     } catch (Dali::DaliException e) {
65099       {
65100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65101       };
65102     } catch (...) {
65103       {
65104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65105       };
65106     }
65107   }
65108
65109   jresult = result;
65110   return jresult;
65111 }
65112
65113
65114 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEvent(void * jarg1, void * jarg2) {
65115   unsigned int jresult ;
65116   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65117   Dali::KeyEvent *arg2 = 0 ;
65118   SwigDirector_ViewImpl *darg = 0;
65119   bool result;
65120
65121   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65122   arg2 = (Dali::KeyEvent *)jarg2;
65123   if (!arg2) {
65124     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
65125     return 0;
65126   }
65127   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65128   if (!darg) {
65129     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65130     return 0;
65131   }
65132   {
65133     try {
65134       result = (bool)(darg)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
65135     } catch (std::out_of_range& e) {
65136       {
65137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65138       };
65139     } catch (std::exception& e) {
65140       {
65141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65142       };
65143     } catch (Dali::DaliException e) {
65144       {
65145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65146       };
65147     } catch (...) {
65148       {
65149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65150       };
65151     }
65152   }
65153
65154   jresult = result;
65155   return jresult;
65156 }
65157
65158
65159 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
65160   unsigned int jresult ;
65161   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65162   Dali::KeyEvent *arg2 = 0 ;
65163   SwigDirector_ViewImpl *darg = 0;
65164   bool result;
65165
65166   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65167   arg2 = (Dali::KeyEvent *)jarg2;
65168   if (!arg2) {
65169     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
65170     return 0;
65171   }
65172   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65173   if (!darg) {
65174     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65175     return 0;
65176   }
65177   {
65178     try {
65179       result = (bool)(darg)->OnKeyEventSwigPublic((Dali::KeyEvent const &)*arg2);
65180     } catch (std::out_of_range& e) {
65181       {
65182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65183       };
65184     } catch (std::exception& e) {
65185       {
65186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65187       };
65188     } catch (Dali::DaliException e) {
65189       {
65190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65191       };
65192     } catch (...) {
65193       {
65194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65195       };
65196     }
65197   }
65198
65199   jresult = result;
65200   return jresult;
65201 }
65202
65203
65204 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEvent(void * jarg1, void * jarg2) {
65205   unsigned int jresult ;
65206   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65207   Dali::WheelEvent *arg2 = 0 ;
65208   SwigDirector_ViewImpl *darg = 0;
65209   bool result;
65210
65211   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65212   arg2 = (Dali::WheelEvent *)jarg2;
65213   if (!arg2) {
65214     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
65215     return 0;
65216   }
65217   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65218   if (!darg) {
65219     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65220     return 0;
65221   }
65222   {
65223     try {
65224       result = (bool)(darg)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
65225     } catch (std::out_of_range& e) {
65226       {
65227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65228       };
65229     } catch (std::exception& e) {
65230       {
65231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65232       };
65233     } catch (Dali::DaliException e) {
65234       {
65235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65236       };
65237     } catch (...) {
65238       {
65239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65240       };
65241     }
65242   }
65243
65244   jresult = result;
65245   return jresult;
65246 }
65247
65248
65249 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
65250   unsigned int jresult ;
65251   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65252   Dali::WheelEvent *arg2 = 0 ;
65253   SwigDirector_ViewImpl *darg = 0;
65254   bool result;
65255
65256   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65257   arg2 = (Dali::WheelEvent *)jarg2;
65258   if (!arg2) {
65259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
65260     return 0;
65261   }
65262   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65263   if (!darg) {
65264     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65265     return 0;
65266   }
65267   {
65268     try {
65269       result = (bool)(darg)->OnWheelEventSwigPublic((Dali::WheelEvent const &)*arg2);
65270     } catch (std::out_of_range& e) {
65271       {
65272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65273       };
65274     } catch (std::exception& e) {
65275       {
65276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65277       };
65278     } catch (Dali::DaliException e) {
65279       {
65280         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65281       };
65282     } catch (...) {
65283       {
65284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65285       };
65286     }
65287   }
65288
65289   jresult = result;
65290   return jresult;
65291 }
65292
65293
65294 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
65295   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65296   Dali::Vector2 *arg2 = 0 ;
65297   Dali::RelayoutContainer *arg3 = 0 ;
65298   SwigDirector_ViewImpl *darg = 0;
65299
65300   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65301   arg2 = (Dali::Vector2 *)jarg2;
65302   if (!arg2) {
65303     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
65304     return ;
65305   }
65306   arg3 = (Dali::RelayoutContainer *)jarg3;
65307   if (!arg3) {
65308     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
65309     return ;
65310   }
65311   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65312   if (!darg) {
65313     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65314     return;
65315   }
65316   {
65317     try {
65318       (darg)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
65319     } catch (std::out_of_range& e) {
65320       {
65321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65322       };
65323     } catch (std::exception& e) {
65324       {
65325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65326       };
65327     } catch (Dali::DaliException e) {
65328       {
65329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65330       };
65331     } catch (...) {
65332       {
65333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65334       };
65335     }
65336   }
65337
65338 }
65339
65340
65341 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayoutSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
65342   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65343   Dali::Vector2 *arg2 = 0 ;
65344   Dali::RelayoutContainer *arg3 = 0 ;
65345   SwigDirector_ViewImpl *darg = 0;
65346
65347   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65348   arg2 = (Dali::Vector2 *)jarg2;
65349   if (!arg2) {
65350     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
65351     return ;
65352   }
65353   arg3 = (Dali::RelayoutContainer *)jarg3;
65354   if (!arg3) {
65355     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
65356     return ;
65357   }
65358   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65359   if (!darg) {
65360     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65361     return;
65362   }
65363   {
65364     try {
65365       (darg)->OnRelayoutSwigPublic((Dali::Vector2 const &)*arg2,*arg3);
65366     } catch (std::out_of_range& e) {
65367       {
65368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65369       };
65370     } catch (std::exception& e) {
65371       {
65372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65373       };
65374     } catch (Dali::DaliException e) {
65375       {
65376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65377       };
65378     } catch (...) {
65379       {
65380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65381       };
65382     }
65383   }
65384
65385 }
65386
65387
65388 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
65389   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65390   Dali::ResizePolicy::Type arg2 ;
65391   Dali::Dimension::Type arg3 ;
65392   SwigDirector_ViewImpl *darg = 0;
65393
65394   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65395   arg2 = (Dali::ResizePolicy::Type)jarg2;
65396   arg3 = (Dali::Dimension::Type)jarg3;
65397   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65398   if (!darg) {
65399     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65400     return;
65401   }
65402   {
65403     try {
65404       (darg)->OnSetResizePolicy(arg2,arg3);
65405     } catch (std::out_of_range& e) {
65406       {
65407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65408       };
65409     } catch (std::exception& e) {
65410       {
65411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65412       };
65413     } catch (Dali::DaliException e) {
65414       {
65415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65416       };
65417     } catch (...) {
65418       {
65419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65420       };
65421     }
65422   }
65423
65424 }
65425
65426
65427 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicySwigExplicitViewImpl(void * jarg1, int jarg2, int jarg3) {
65428   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65429   Dali::ResizePolicy::Type arg2 ;
65430   Dali::Dimension::Type arg3 ;
65431   SwigDirector_ViewImpl *darg = 0;
65432
65433   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65434   arg2 = (Dali::ResizePolicy::Type)jarg2;
65435   arg3 = (Dali::Dimension::Type)jarg3;
65436   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65437   if (!darg) {
65438     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65439     return;
65440   }
65441   {
65442     try {
65443       (darg)->OnSetResizePolicySwigPublic(arg2,arg3);
65444     } catch (std::out_of_range& e) {
65445       {
65446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65447       };
65448     } catch (std::exception& e) {
65449       {
65450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65451       };
65452     } catch (Dali::DaliException e) {
65453       {
65454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65455       };
65456     } catch (...) {
65457       {
65458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65459       };
65460     }
65461   }
65462
65463 }
65464
65465
65466 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSize(void * jarg1) {
65467   void * jresult ;
65468   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65469   SwigDirector_ViewImpl *darg = 0;
65470   Dali::Vector3 result;
65471
65472   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65473   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65474   if (!darg) {
65475     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65476     return 0;
65477   }
65478   {
65479     try {
65480       result = (darg)->GetNaturalSize();
65481     } catch (std::out_of_range& e) {
65482       {
65483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65484       };
65485     } catch (std::exception& e) {
65486       {
65487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65488       };
65489     } catch (Dali::DaliException e) {
65490       {
65491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65492       };
65493     } catch (...) {
65494       {
65495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65496       };
65497     }
65498   }
65499
65500   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
65501   return jresult;
65502 }
65503
65504
65505 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSizeSwigExplicitViewImpl(void * jarg1) {
65506   void * jresult ;
65507   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65508   SwigDirector_ViewImpl *darg = 0;
65509   Dali::Vector3 result;
65510
65511   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65512   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65513   if (!darg) {
65514     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65515     return 0;
65516   }
65517   {
65518     try {
65519       result = (darg)->GetNaturalSizeSwigPublic();
65520     } catch (std::out_of_range& e) {
65521       {
65522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65523       };
65524     } catch (std::exception& e) {
65525       {
65526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65527       };
65528     } catch (Dali::DaliException e) {
65529       {
65530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65531       };
65532     } catch (...) {
65533       {
65534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65535       };
65536     }
65537   }
65538
65539   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
65540   return jresult;
65541 }
65542
65543
65544 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
65545   float jresult ;
65546   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65547   Dali::Actor *arg2 = 0 ;
65548   Dali::Dimension::Type arg3 ;
65549   SwigDirector_ViewImpl *darg = 0;
65550   float result;
65551
65552   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65553   arg2 = (Dali::Actor *)jarg2;
65554   if (!arg2) {
65555     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
65556     return 0;
65557   }
65558   arg3 = (Dali::Dimension::Type)jarg3;
65559   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65560   if (!darg) {
65561     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65562     return 0;
65563   }
65564   {
65565     try {
65566       result = (float)(darg)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
65567     } catch (std::out_of_range& e) {
65568       {
65569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65570       };
65571     } catch (std::exception& e) {
65572       {
65573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65574       };
65575     } catch (Dali::DaliException e) {
65576       {
65577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65578       };
65579     } catch (...) {
65580       {
65581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65582       };
65583     }
65584   }
65585
65586   jresult = result;
65587   return jresult;
65588 }
65589
65590
65591 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSizeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
65592   float jresult ;
65593   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65594   Dali::Actor *arg2 = 0 ;
65595   Dali::Dimension::Type arg3 ;
65596   SwigDirector_ViewImpl *darg = 0;
65597   float result;
65598
65599   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65600   arg2 = (Dali::Actor *)jarg2;
65601   if (!arg2) {
65602     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
65603     return 0;
65604   }
65605   arg3 = (Dali::Dimension::Type)jarg3;
65606   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65607   if (!darg) {
65608     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65609     return 0;
65610   }
65611   {
65612     try {
65613       result = (float)(darg)->CalculateChildSizeSwigPublic((Dali::Actor const &)*arg2,arg3);
65614     } catch (std::out_of_range& e) {
65615       {
65616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65617       };
65618     } catch (std::exception& e) {
65619       {
65620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65621       };
65622     } catch (Dali::DaliException e) {
65623       {
65624         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65625       };
65626     } catch (...) {
65627       {
65628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65629       };
65630     }
65631   }
65632
65633   jresult = result;
65634   return jresult;
65635 }
65636
65637
65638 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidth(void * jarg1, float jarg2) {
65639   float jresult ;
65640   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65641   float arg2 ;
65642   SwigDirector_ViewImpl *darg = 0;
65643   float result;
65644
65645   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65646   arg2 = (float)jarg2;
65647   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65648   if (!darg) {
65649     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65650     return 0;
65651   }
65652   {
65653     try {
65654       result = (float)(darg)->GetHeightForWidth(arg2);
65655     } catch (std::out_of_range& e) {
65656       {
65657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65658       };
65659     } catch (std::exception& e) {
65660       {
65661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65662       };
65663     } catch (Dali::DaliException e) {
65664       {
65665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65666       };
65667     } catch (...) {
65668       {
65669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65670       };
65671     }
65672   }
65673
65674   jresult = result;
65675   return jresult;
65676 }
65677
65678
65679 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidthSwigExplicitViewImpl(void * jarg1, float jarg2) {
65680   float jresult ;
65681   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65682   float arg2 ;
65683   SwigDirector_ViewImpl *darg = 0;
65684   float result;
65685
65686   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65687   arg2 = (float)jarg2;
65688   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65689   if (!darg) {
65690     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65691     return 0;
65692   }
65693   {
65694     try {
65695       result = (float)(darg)->GetHeightForWidthSwigPublic(arg2);
65696     } catch (std::out_of_range& e) {
65697       {
65698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65699       };
65700     } catch (std::exception& e) {
65701       {
65702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65703       };
65704     } catch (Dali::DaliException e) {
65705       {
65706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65707       };
65708     } catch (...) {
65709       {
65710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65711       };
65712     }
65713   }
65714
65715   jresult = result;
65716   return jresult;
65717 }
65718
65719
65720 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeight(void * jarg1, float jarg2) {
65721   float jresult ;
65722   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65723   float arg2 ;
65724   SwigDirector_ViewImpl *darg = 0;
65725   float result;
65726
65727   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65728   arg2 = (float)jarg2;
65729   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65730   if (!darg) {
65731     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65732     return 0;
65733   }
65734   {
65735     try {
65736       result = (float)(darg)->GetWidthForHeight(arg2);
65737     } catch (std::out_of_range& e) {
65738       {
65739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65740       };
65741     } catch (std::exception& e) {
65742       {
65743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65744       };
65745     } catch (Dali::DaliException e) {
65746       {
65747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65748       };
65749     } catch (...) {
65750       {
65751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65752       };
65753     }
65754   }
65755
65756   jresult = result;
65757   return jresult;
65758 }
65759
65760
65761 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeightSwigExplicitViewImpl(void * jarg1, float jarg2) {
65762   float jresult ;
65763   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65764   float arg2 ;
65765   SwigDirector_ViewImpl *darg = 0;
65766   float result;
65767
65768   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65769   arg2 = (float)jarg2;
65770   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65771   if (!darg) {
65772     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65773     return 0;
65774   }
65775   {
65776     try {
65777       result = (float)(darg)->GetWidthForHeightSwigPublic(arg2);
65778     } catch (std::out_of_range& e) {
65779       {
65780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65781       };
65782     } catch (std::exception& e) {
65783       {
65784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65785       };
65786     } catch (Dali::DaliException e) {
65787       {
65788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65789       };
65790     } catch (...) {
65791       {
65792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65793       };
65794     }
65795   }
65796
65797   jresult = result;
65798   return jresult;
65799 }
65800
65801
65802 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
65803   unsigned int jresult ;
65804   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65805   Dali::Dimension::Type arg2 ;
65806   SwigDirector_ViewImpl *darg = 0;
65807   bool result;
65808
65809   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65810   arg2 = (Dali::Dimension::Type)jarg2;
65811   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65812   if (!darg) {
65813     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65814     return 0;
65815   }
65816   {
65817     try {
65818       result = (bool)(darg)->RelayoutDependentOnChildren(arg2);
65819     } catch (std::out_of_range& e) {
65820       {
65821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65822       };
65823     } catch (std::exception& e) {
65824       {
65825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65826       };
65827     } catch (Dali::DaliException e) {
65828       {
65829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65830       };
65831     } catch (...) {
65832       {
65833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65834       };
65835     }
65836   }
65837
65838   jresult = result;
65839   return jresult;
65840 }
65841
65842
65843 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_0(void * jarg1, int jarg2) {
65844   unsigned int jresult ;
65845   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65846   Dali::Dimension::Type arg2 ;
65847   SwigDirector_ViewImpl *darg = 0;
65848   bool result;
65849
65850   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65851   arg2 = (Dali::Dimension::Type)jarg2;
65852   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65853   if (!darg) {
65854     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65855     return 0;
65856   }
65857   {
65858     try {
65859       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic(arg2);
65860     } catch (std::out_of_range& e) {
65861       {
65862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65863       };
65864     } catch (std::exception& e) {
65865       {
65866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65867       };
65868     } catch (Dali::DaliException e) {
65869       {
65870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65871       };
65872     } catch (...) {
65873       {
65874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65875       };
65876     }
65877   }
65878
65879   jresult = result;
65880   return jresult;
65881 }
65882
65883
65884 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
65885   unsigned int jresult ;
65886   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65887   SwigDirector_ViewImpl *darg = 0;
65888   bool result;
65889
65890   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65891   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65892   if (!darg) {
65893     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65894     return 0;
65895   }
65896   {
65897     try {
65898       result = (bool)(darg)->RelayoutDependentOnChildren();
65899     } catch (std::out_of_range& e) {
65900       {
65901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65902       };
65903     } catch (std::exception& e) {
65904       {
65905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65906       };
65907     } catch (Dali::DaliException e) {
65908       {
65909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65910       };
65911     } catch (...) {
65912       {
65913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65914       };
65915     }
65916   }
65917
65918   jresult = result;
65919   return jresult;
65920 }
65921
65922
65923 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_1(void * jarg1) {
65924   unsigned int jresult ;
65925   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65926   SwigDirector_ViewImpl *darg = 0;
65927   bool result;
65928
65929   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65930   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65931   if (!darg) {
65932     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65933     return 0;
65934   }
65935   {
65936     try {
65937       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic();
65938     } catch (std::out_of_range& e) {
65939       {
65940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65941       };
65942     } catch (std::exception& e) {
65943       {
65944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65945       };
65946     } catch (Dali::DaliException e) {
65947       {
65948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65949       };
65950     } catch (...) {
65951       {
65952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65953       };
65954     }
65955   }
65956
65957   jresult = result;
65958   return jresult;
65959 }
65960
65961
65962 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
65963   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65964   Dali::Dimension::Type arg2 ;
65965   SwigDirector_ViewImpl *darg = 0;
65966
65967   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65968   arg2 = (Dali::Dimension::Type)jarg2;
65969   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65970   if (!darg) {
65971     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65972     return;
65973   }
65974   {
65975     try {
65976       (darg)->OnCalculateRelayoutSize(arg2);
65977     } catch (std::out_of_range& e) {
65978       {
65979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65980       };
65981     } catch (std::exception& e) {
65982       {
65983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65984       };
65985     } catch (Dali::DaliException e) {
65986       {
65987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65988       };
65989     } catch (...) {
65990       {
65991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65992       };
65993     }
65994   }
65995
65996 }
65997
65998
65999 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSizeSwigExplicitViewImpl(void * jarg1, int jarg2) {
66000   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66001   Dali::Dimension::Type arg2 ;
66002   SwigDirector_ViewImpl *darg = 0;
66003
66004   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66005   arg2 = (Dali::Dimension::Type)jarg2;
66006   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
66007   if (!darg) {
66008     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
66009     return;
66010   }
66011   {
66012     try {
66013       (darg)->OnCalculateRelayoutSizeSwigPublic(arg2);
66014     } catch (std::out_of_range& e) {
66015       {
66016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66017       };
66018     } catch (std::exception& e) {
66019       {
66020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66021       };
66022     } catch (Dali::DaliException e) {
66023       {
66024         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66025       };
66026     } catch (...) {
66027       {
66028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66029       };
66030     }
66031   }
66032
66033 }
66034
66035
66036 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
66037   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66038   float arg2 ;
66039   Dali::Dimension::Type arg3 ;
66040   SwigDirector_ViewImpl *darg = 0;
66041
66042   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66043   arg2 = (float)jarg2;
66044   arg3 = (Dali::Dimension::Type)jarg3;
66045   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
66046   if (!darg) {
66047     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
66048     return;
66049   }
66050   {
66051     try {
66052       (darg)->OnLayoutNegotiated(arg2,arg3);
66053     } catch (std::out_of_range& e) {
66054       {
66055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66056       };
66057     } catch (std::exception& e) {
66058       {
66059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66060       };
66061     } catch (Dali::DaliException e) {
66062       {
66063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66064       };
66065     } catch (...) {
66066       {
66067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66068       };
66069     }
66070   }
66071
66072 }
66073
66074
66075 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiatedSwigExplicitViewImpl(void * jarg1, float jarg2, int jarg3) {
66076   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66077   float arg2 ;
66078   Dali::Dimension::Type arg3 ;
66079   SwigDirector_ViewImpl *darg = 0;
66080
66081   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66082   arg2 = (float)jarg2;
66083   arg3 = (Dali::Dimension::Type)jarg3;
66084   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
66085   if (!darg) {
66086     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
66087     return;
66088   }
66089   {
66090     try {
66091       (darg)->OnLayoutNegotiatedSwigPublic(arg2,arg3);
66092     } catch (std::out_of_range& e) {
66093       {
66094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66095       };
66096     } catch (std::exception& e) {
66097       {
66098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66099       };
66100     } catch (Dali::DaliException e) {
66101       {
66102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66103       };
66104     } catch (...) {
66105       {
66106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66107       };
66108     }
66109   }
66110
66111 }
66112
66113
66114 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitialize(void * jarg1) {
66115   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66116
66117   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66118   {
66119     try {
66120       (arg1)->OnInitialize();
66121     } catch (std::out_of_range& e) {
66122       {
66123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66124       };
66125     } catch (std::exception& e) {
66126       {
66127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66128       };
66129     } catch (Dali::DaliException e) {
66130       {
66131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66132       };
66133     } catch (...) {
66134       {
66135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66136       };
66137     }
66138   }
66139
66140 }
66141
66142
66143 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitializeSwigExplicitViewImpl(void * jarg1) {
66144   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66145
66146   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66147   {
66148     try {
66149       (arg1)->Dali::Toolkit::Internal::Control::OnInitialize();
66150     } catch (std::out_of_range& e) {
66151       {
66152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66153       };
66154     } catch (std::exception& e) {
66155       {
66156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66157       };
66158     } catch (Dali::DaliException e) {
66159       {
66160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66161       };
66162     } catch (...) {
66163       {
66164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66165       };
66166     }
66167   }
66168
66169 }
66170
66171
66172 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAdd(void * jarg1, void * jarg2) {
66173   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66174   Dali::Actor *arg2 = 0 ;
66175
66176   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66177   arg2 = (Dali::Actor *)jarg2;
66178   if (!arg2) {
66179     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
66180     return ;
66181   }
66182   {
66183     try {
66184       (arg1)->OnControlChildAdd(*arg2);
66185     } catch (std::out_of_range& e) {
66186       {
66187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66188       };
66189     } catch (std::exception& e) {
66190       {
66191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66192       };
66193     } catch (Dali::DaliException e) {
66194       {
66195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66196       };
66197     } catch (...) {
66198       {
66199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66200       };
66201     }
66202   }
66203
66204 }
66205
66206
66207 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66208   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66209   Dali::Actor *arg2 = 0 ;
66210
66211   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66212   arg2 = (Dali::Actor *)jarg2;
66213   if (!arg2) {
66214     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
66215     return ;
66216   }
66217   {
66218     try {
66219       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildAdd(*arg2);
66220     } catch (std::out_of_range& e) {
66221       {
66222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66223       };
66224     } catch (std::exception& e) {
66225       {
66226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66227       };
66228     } catch (Dali::DaliException e) {
66229       {
66230         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66231       };
66232     } catch (...) {
66233       {
66234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66235       };
66236     }
66237   }
66238
66239 }
66240
66241
66242 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemove(void * jarg1, void * jarg2) {
66243   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66244   Dali::Actor *arg2 = 0 ;
66245
66246   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66247   arg2 = (Dali::Actor *)jarg2;
66248   if (!arg2) {
66249     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
66250     return ;
66251   }
66252   {
66253     try {
66254       (arg1)->OnControlChildRemove(*arg2);
66255     } catch (std::out_of_range& e) {
66256       {
66257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66258       };
66259     } catch (std::exception& e) {
66260       {
66261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66262       };
66263     } catch (Dali::DaliException e) {
66264       {
66265         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66266       };
66267     } catch (...) {
66268       {
66269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66270       };
66271     }
66272   }
66273
66274 }
66275
66276
66277 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66278   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66279   Dali::Actor *arg2 = 0 ;
66280
66281   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66282   arg2 = (Dali::Actor *)jarg2;
66283   if (!arg2) {
66284     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
66285     return ;
66286   }
66287   {
66288     try {
66289       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildRemove(*arg2);
66290     } catch (std::out_of_range& e) {
66291       {
66292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66293       };
66294     } catch (std::exception& e) {
66295       {
66296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66297       };
66298     } catch (Dali::DaliException e) {
66299       {
66300         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66301       };
66302     } catch (...) {
66303       {
66304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66305       };
66306     }
66307   }
66308
66309 }
66310
66311
66312 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChange(void * jarg1, void * jarg2, int jarg3) {
66313   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66314   Dali::Toolkit::StyleManager arg2 ;
66315   Dali::StyleChange::Type arg3 ;
66316   Dali::Toolkit::StyleManager *argp2 ;
66317
66318   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66319   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
66320   if (!argp2) {
66321     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
66322     return ;
66323   }
66324   arg2 = *argp2;
66325   arg3 = (Dali::StyleChange::Type)jarg3;
66326   {
66327     try {
66328       (arg1)->OnStyleChange(arg2,arg3);
66329     } catch (std::out_of_range& e) {
66330       {
66331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66332       };
66333     } catch (std::exception& e) {
66334       {
66335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66336       };
66337     } catch (Dali::DaliException e) {
66338       {
66339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66340       };
66341     } catch (...) {
66342       {
66343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66344       };
66345     }
66346   }
66347
66348 }
66349
66350
66351 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChangeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
66352   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66353   Dali::Toolkit::StyleManager arg2 ;
66354   Dali::StyleChange::Type arg3 ;
66355   Dali::Toolkit::StyleManager *argp2 ;
66356
66357   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66358   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
66359   if (!argp2) {
66360     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
66361     return ;
66362   }
66363   arg2 = *argp2;
66364   arg3 = (Dali::StyleChange::Type)jarg3;
66365   {
66366     try {
66367       (arg1)->Dali::Toolkit::Internal::Control::OnStyleChange(arg2,arg3);
66368     } catch (std::out_of_range& e) {
66369       {
66370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66371       };
66372     } catch (std::exception& e) {
66373       {
66374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66375       };
66376     } catch (Dali::DaliException e) {
66377       {
66378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66379       };
66380     } catch (...) {
66381       {
66382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66383       };
66384     }
66385   }
66386
66387 }
66388
66389
66390 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivated(void * jarg1) {
66391   unsigned int jresult ;
66392   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66393   bool result;
66394
66395   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66396   {
66397     try {
66398       result = (bool)(arg1)->OnAccessibilityActivated();
66399     } catch (std::out_of_range& e) {
66400       {
66401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66402       };
66403     } catch (std::exception& e) {
66404       {
66405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66406       };
66407     } catch (Dali::DaliException e) {
66408       {
66409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66410       };
66411     } catch (...) {
66412       {
66413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66414       };
66415     }
66416   }
66417
66418   jresult = result;
66419   return jresult;
66420 }
66421
66422
66423 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivatedSwigExplicitViewImpl(void * jarg1) {
66424   unsigned int jresult ;
66425   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66426   bool result;
66427
66428   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66429   {
66430     try {
66431       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
66432     } catch (std::out_of_range& e) {
66433       {
66434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66435       };
66436     } catch (std::exception& e) {
66437       {
66438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66439       };
66440     } catch (Dali::DaliException e) {
66441       {
66442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66443       };
66444     } catch (...) {
66445       {
66446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66447       };
66448     }
66449   }
66450
66451   jresult = result;
66452   return jresult;
66453 }
66454
66455
66456 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPan(void * jarg1, void * jarg2) {
66457   unsigned int jresult ;
66458   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66459   Dali::PanGesture arg2 ;
66460   Dali::PanGesture *argp2 ;
66461   bool result;
66462
66463   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66464   argp2 = (Dali::PanGesture *)jarg2;
66465   if (!argp2) {
66466     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
66467     return 0;
66468   }
66469   arg2 = *argp2;
66470   {
66471     try {
66472       result = (bool)(arg1)->OnAccessibilityPan(arg2);
66473     } catch (std::out_of_range& e) {
66474       {
66475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66476       };
66477     } catch (std::exception& e) {
66478       {
66479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66480       };
66481     } catch (Dali::DaliException e) {
66482       {
66483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66484       };
66485     } catch (...) {
66486       {
66487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66488       };
66489     }
66490   }
66491
66492   jresult = result;
66493   return jresult;
66494 }
66495
66496
66497 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66498   unsigned int jresult ;
66499   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66500   Dali::PanGesture arg2 ;
66501   Dali::PanGesture *argp2 ;
66502   bool result;
66503
66504   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66505   argp2 = (Dali::PanGesture *)jarg2;
66506   if (!argp2) {
66507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
66508     return 0;
66509   }
66510   arg2 = *argp2;
66511   {
66512     try {
66513       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityPan(arg2);
66514     } catch (std::out_of_range& e) {
66515       {
66516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66517       };
66518     } catch (std::exception& e) {
66519       {
66520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66521       };
66522     } catch (Dali::DaliException e) {
66523       {
66524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66525       };
66526     } catch (...) {
66527       {
66528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66529       };
66530     }
66531   }
66532
66533   jresult = result;
66534   return jresult;
66535 }
66536
66537
66538 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouch(void * jarg1, void * jarg2) {
66539   unsigned int jresult ;
66540   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66541   Dali::TouchEvent *arg2 = 0 ;
66542   bool result;
66543
66544   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66545   arg2 = (Dali::TouchEvent *)jarg2;
66546   if (!arg2) {
66547     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
66548     return 0;
66549   }
66550   {
66551     try {
66552       result = (bool)(arg1)->OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
66553     } catch (std::out_of_range& e) {
66554       {
66555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66556       };
66557     } catch (std::exception& e) {
66558       {
66559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66560       };
66561     } catch (Dali::DaliException e) {
66562       {
66563         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66564       };
66565     } catch (...) {
66566       {
66567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66568       };
66569     }
66570   }
66571
66572   jresult = result;
66573   return jresult;
66574 }
66575
66576
66577 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66578   unsigned int jresult ;
66579   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66580   Dali::TouchEvent *arg2 = 0 ;
66581   bool result;
66582
66583   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66584   arg2 = (Dali::TouchEvent *)jarg2;
66585   if (!arg2) {
66586     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
66587     return 0;
66588   }
66589   {
66590     try {
66591       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
66592     } catch (std::out_of_range& e) {
66593       {
66594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66595       };
66596     } catch (std::exception& e) {
66597       {
66598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66599       };
66600     } catch (Dali::DaliException e) {
66601       {
66602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66603       };
66604     } catch (...) {
66605       {
66606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66607       };
66608     }
66609   }
66610
66611   jresult = result;
66612   return jresult;
66613 }
66614
66615
66616 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChange(void * jarg1, unsigned int jarg2) {
66617   unsigned int jresult ;
66618   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66619   bool arg2 ;
66620   bool result;
66621
66622   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66623   arg2 = jarg2 ? true : false;
66624   {
66625     try {
66626       result = (bool)(arg1)->OnAccessibilityValueChange(arg2);
66627     } catch (std::out_of_range& e) {
66628       {
66629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66630       };
66631     } catch (std::exception& e) {
66632       {
66633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66634       };
66635     } catch (Dali::DaliException e) {
66636       {
66637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66638       };
66639     } catch (...) {
66640       {
66641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66642       };
66643     }
66644   }
66645
66646   jresult = result;
66647   return jresult;
66648 }
66649
66650
66651 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChangeSwigExplicitViewImpl(void * jarg1, unsigned int jarg2) {
66652   unsigned int jresult ;
66653   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66654   bool arg2 ;
66655   bool result;
66656
66657   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66658   arg2 = jarg2 ? true : false;
66659   {
66660     try {
66661       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(arg2);
66662     } catch (std::out_of_range& e) {
66663       {
66664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66665       };
66666     } catch (std::exception& e) {
66667       {
66668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66669       };
66670     } catch (Dali::DaliException e) {
66671       {
66672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66673       };
66674     } catch (...) {
66675       {
66676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66677       };
66678     }
66679   }
66680
66681   jresult = result;
66682   return jresult;
66683 }
66684
66685
66686 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoom(void * jarg1) {
66687   unsigned int jresult ;
66688   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66689   bool result;
66690
66691   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66692   {
66693     try {
66694       result = (bool)(arg1)->OnAccessibilityZoom();
66695     } catch (std::out_of_range& e) {
66696       {
66697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66698       };
66699     } catch (std::exception& e) {
66700       {
66701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66702       };
66703     } catch (Dali::DaliException e) {
66704       {
66705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66706       };
66707     } catch (...) {
66708       {
66709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66710       };
66711     }
66712   }
66713
66714   jresult = result;
66715   return jresult;
66716 }
66717
66718
66719 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoomSwigExplicitViewImpl(void * jarg1) {
66720   unsigned int jresult ;
66721   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66722   bool result;
66723
66724   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66725   {
66726     try {
66727       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
66728     } catch (std::out_of_range& e) {
66729       {
66730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66731       };
66732     } catch (std::exception& e) {
66733       {
66734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66735       };
66736     } catch (Dali::DaliException e) {
66737       {
66738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66739       };
66740     } catch (...) {
66741       {
66742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66743       };
66744     }
66745   }
66746
66747   jresult = result;
66748   return jresult;
66749 }
66750
66751
66752 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGained(void * jarg1) {
66753   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66754
66755   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66756   {
66757     try {
66758       (arg1)->OnKeyInputFocusGained();
66759     } catch (std::out_of_range& e) {
66760       {
66761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66762       };
66763     } catch (std::exception& e) {
66764       {
66765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66766       };
66767     } catch (Dali::DaliException e) {
66768       {
66769         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66770       };
66771     } catch (...) {
66772       {
66773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66774       };
66775     }
66776   }
66777
66778 }
66779
66780
66781 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGainedSwigExplicitViewImpl(void * jarg1) {
66782   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66783
66784   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66785   {
66786     try {
66787       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
66788     } catch (std::out_of_range& e) {
66789       {
66790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66791       };
66792     } catch (std::exception& e) {
66793       {
66794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66795       };
66796     } catch (Dali::DaliException e) {
66797       {
66798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66799       };
66800     } catch (...) {
66801       {
66802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66803       };
66804     }
66805   }
66806
66807 }
66808
66809
66810 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLost(void * jarg1) {
66811   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66812
66813   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66814   {
66815     try {
66816       (arg1)->OnKeyInputFocusLost();
66817     } catch (std::out_of_range& e) {
66818       {
66819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66820       };
66821     } catch (std::exception& e) {
66822       {
66823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66824       };
66825     } catch (Dali::DaliException e) {
66826       {
66827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66828       };
66829     } catch (...) {
66830       {
66831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66832       };
66833     }
66834   }
66835
66836 }
66837
66838
66839 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLostSwigExplicitViewImpl(void * jarg1) {
66840   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66841
66842   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66843   {
66844     try {
66845       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
66846     } catch (std::out_of_range& e) {
66847       {
66848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66849       };
66850     } catch (std::exception& e) {
66851       {
66852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66853       };
66854     } catch (Dali::DaliException e) {
66855       {
66856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66857       };
66858     } catch (...) {
66859       {
66860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66861       };
66862     }
66863   }
66864
66865 }
66866
66867
66868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActor(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
66869   void * jresult ;
66870   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66871   Dali::Actor arg2 ;
66872   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
66873   bool arg4 ;
66874   Dali::Actor *argp2 ;
66875   Dali::Actor result;
66876
66877   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66878   argp2 = (Dali::Actor *)jarg2;
66879   if (!argp2) {
66880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66881     return 0;
66882   }
66883   arg2 = *argp2;
66884   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
66885   arg4 = jarg4 ? true : false;
66886   {
66887     try {
66888       result = (arg1)->GetNextKeyboardFocusableActor(arg2,arg3,arg4);
66889     } catch (std::out_of_range& e) {
66890       {
66891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66892       };
66893     } catch (std::exception& e) {
66894       {
66895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66896       };
66897     } catch (Dali::DaliException e) {
66898       {
66899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66900       };
66901     } catch (...) {
66902       {
66903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66904       };
66905     }
66906   }
66907
66908   jresult = new Dali::Actor((const Dali::Actor &)result);
66909   return jresult;
66910 }
66911
66912
66913 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActorSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
66914   void * jresult ;
66915   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66916   Dali::Actor arg2 ;
66917   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
66918   bool arg4 ;
66919   Dali::Actor *argp2 ;
66920   Dali::Actor result;
66921
66922   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66923   argp2 = (Dali::Actor *)jarg2;
66924   if (!argp2) {
66925     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66926     return 0;
66927   }
66928   arg2 = *argp2;
66929   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
66930   arg4 = jarg4 ? true : false;
66931   {
66932     try {
66933       result = (arg1)->Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(arg2,arg3,arg4);
66934     } catch (std::out_of_range& e) {
66935       {
66936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66937       };
66938     } catch (std::exception& e) {
66939       {
66940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66941       };
66942     } catch (Dali::DaliException e) {
66943       {
66944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66945       };
66946     } catch (...) {
66947       {
66948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66949       };
66950     }
66951   }
66952
66953   jresult = new Dali::Actor((const Dali::Actor &)result);
66954   return jresult;
66955 }
66956
66957
66958 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommitted(void * jarg1, void * jarg2) {
66959   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66960   Dali::Actor arg2 ;
66961   Dali::Actor *argp2 ;
66962
66963   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66964   argp2 = (Dali::Actor *)jarg2;
66965   if (!argp2) {
66966     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66967     return ;
66968   }
66969   arg2 = *argp2;
66970   {
66971     try {
66972       (arg1)->OnKeyboardFocusChangeCommitted(arg2);
66973     } catch (std::out_of_range& e) {
66974       {
66975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66976       };
66977     } catch (std::exception& e) {
66978       {
66979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66980       };
66981     } catch (Dali::DaliException e) {
66982       {
66983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66984       };
66985     } catch (...) {
66986       {
66987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66988       };
66989     }
66990   }
66991
66992 }
66993
66994
66995 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommittedSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66996   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66997   Dali::Actor arg2 ;
66998   Dali::Actor *argp2 ;
66999
67000   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67001   argp2 = (Dali::Actor *)jarg2;
67002   if (!argp2) {
67003     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
67004     return ;
67005   }
67006   arg2 = *argp2;
67007   {
67008     try {
67009       (arg1)->Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(arg2);
67010     } catch (std::out_of_range& e) {
67011       {
67012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67013       };
67014     } catch (std::exception& e) {
67015       {
67016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67017       };
67018     } catch (Dali::DaliException e) {
67019       {
67020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67021       };
67022     } catch (...) {
67023       {
67024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67025       };
67026     }
67027   }
67028
67029 }
67030
67031
67032 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnter(void * jarg1) {
67033   unsigned int jresult ;
67034   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67035   bool result;
67036
67037   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67038   {
67039     try {
67040       result = (bool)(arg1)->OnKeyboardEnter();
67041     } catch (std::out_of_range& e) {
67042       {
67043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67044       };
67045     } catch (std::exception& e) {
67046       {
67047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67048       };
67049     } catch (Dali::DaliException e) {
67050       {
67051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67052       };
67053     } catch (...) {
67054       {
67055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67056       };
67057     }
67058   }
67059
67060   jresult = result;
67061   return jresult;
67062 }
67063
67064
67065 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnterSwigExplicitViewImpl(void * jarg1) {
67066   unsigned int jresult ;
67067   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67068   bool result;
67069
67070   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67071   {
67072     try {
67073       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnKeyboardEnter();
67074     } catch (std::out_of_range& e) {
67075       {
67076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67077       };
67078     } catch (std::exception& e) {
67079       {
67080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67081       };
67082     } catch (Dali::DaliException e) {
67083       {
67084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67085       };
67086     } catch (...) {
67087       {
67088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67089       };
67090     }
67091   }
67092
67093   jresult = result;
67094   return jresult;
67095 }
67096
67097
67098 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinch(void * jarg1, void * jarg2) {
67099   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67100   Dali::PinchGesture *arg2 = 0 ;
67101
67102   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67103   arg2 = (Dali::PinchGesture *)jarg2;
67104   if (!arg2) {
67105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
67106     return ;
67107   }
67108   {
67109     try {
67110       (arg1)->OnPinch((Dali::PinchGesture const &)*arg2);
67111     } catch (std::out_of_range& e) {
67112       {
67113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67114       };
67115     } catch (std::exception& e) {
67116       {
67117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67118       };
67119     } catch (Dali::DaliException e) {
67120       {
67121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67122       };
67123     } catch (...) {
67124       {
67125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67126       };
67127     }
67128   }
67129
67130 }
67131
67132
67133 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
67134   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67135   Dali::PinchGesture *arg2 = 0 ;
67136
67137   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67138   arg2 = (Dali::PinchGesture *)jarg2;
67139   if (!arg2) {
67140     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
67141     return ;
67142   }
67143   {
67144     try {
67145       (arg1)->Dali::Toolkit::Internal::Control::OnPinch((Dali::PinchGesture const &)*arg2);
67146     } catch (std::out_of_range& e) {
67147       {
67148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67149       };
67150     } catch (std::exception& e) {
67151       {
67152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67153       };
67154     } catch (Dali::DaliException e) {
67155       {
67156         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67157       };
67158     } catch (...) {
67159       {
67160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67161       };
67162     }
67163   }
67164
67165 }
67166
67167
67168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPan(void * jarg1, void * jarg2) {
67169   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67170   Dali::PanGesture *arg2 = 0 ;
67171
67172   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67173   arg2 = (Dali::PanGesture *)jarg2;
67174   if (!arg2) {
67175     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
67176     return ;
67177   }
67178   {
67179     try {
67180       (arg1)->OnPan((Dali::PanGesture const &)*arg2);
67181     } catch (std::out_of_range& e) {
67182       {
67183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67184       };
67185     } catch (std::exception& e) {
67186       {
67187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67188       };
67189     } catch (Dali::DaliException e) {
67190       {
67191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67192       };
67193     } catch (...) {
67194       {
67195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67196       };
67197     }
67198   }
67199
67200 }
67201
67202
67203 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
67204   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67205   Dali::PanGesture *arg2 = 0 ;
67206
67207   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67208   arg2 = (Dali::PanGesture *)jarg2;
67209   if (!arg2) {
67210     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
67211     return ;
67212   }
67213   {
67214     try {
67215       (arg1)->Dali::Toolkit::Internal::Control::OnPan((Dali::PanGesture const &)*arg2);
67216     } catch (std::out_of_range& e) {
67217       {
67218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67219       };
67220     } catch (std::exception& e) {
67221       {
67222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67223       };
67224     } catch (Dali::DaliException e) {
67225       {
67226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67227       };
67228     } catch (...) {
67229       {
67230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67231       };
67232     }
67233   }
67234
67235 }
67236
67237
67238 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTap(void * jarg1, void * jarg2) {
67239   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67240   Dali::TapGesture *arg2 = 0 ;
67241
67242   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67243   arg2 = (Dali::TapGesture *)jarg2;
67244   if (!arg2) {
67245     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
67246     return ;
67247   }
67248   {
67249     try {
67250       (arg1)->OnTap((Dali::TapGesture const &)*arg2);
67251     } catch (std::out_of_range& e) {
67252       {
67253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67254       };
67255     } catch (std::exception& e) {
67256       {
67257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67258       };
67259     } catch (Dali::DaliException e) {
67260       {
67261         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67262       };
67263     } catch (...) {
67264       {
67265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67266       };
67267     }
67268   }
67269
67270 }
67271
67272
67273 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTapSwigExplicitViewImpl(void * jarg1, void * jarg2) {
67274   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67275   Dali::TapGesture *arg2 = 0 ;
67276
67277   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67278   arg2 = (Dali::TapGesture *)jarg2;
67279   if (!arg2) {
67280     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
67281     return ;
67282   }
67283   {
67284     try {
67285       (arg1)->Dali::Toolkit::Internal::Control::OnTap((Dali::TapGesture const &)*arg2);
67286     } catch (std::out_of_range& e) {
67287       {
67288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67289       };
67290     } catch (std::exception& e) {
67291       {
67292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67293       };
67294     } catch (Dali::DaliException e) {
67295       {
67296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67297       };
67298     } catch (...) {
67299       {
67300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67301       };
67302     }
67303   }
67304
67305 }
67306
67307
67308 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPress(void * jarg1, void * jarg2) {
67309   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67310   Dali::LongPressGesture *arg2 = 0 ;
67311
67312   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67313   arg2 = (Dali::LongPressGesture *)jarg2;
67314   if (!arg2) {
67315     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
67316     return ;
67317   }
67318   {
67319     try {
67320       (arg1)->OnLongPress((Dali::LongPressGesture const &)*arg2);
67321     } catch (std::out_of_range& e) {
67322       {
67323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67324       };
67325     } catch (std::exception& e) {
67326       {
67327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67328       };
67329     } catch (Dali::DaliException e) {
67330       {
67331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67332       };
67333     } catch (...) {
67334       {
67335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67336       };
67337     }
67338   }
67339
67340 }
67341
67342
67343 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPressSwigExplicitViewImpl(void * jarg1, void * jarg2) {
67344   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67345   Dali::LongPressGesture *arg2 = 0 ;
67346
67347   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67348   arg2 = (Dali::LongPressGesture *)jarg2;
67349   if (!arg2) {
67350     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
67351     return ;
67352   }
67353   {
67354     try {
67355       (arg1)->Dali::Toolkit::Internal::Control::OnLongPress((Dali::LongPressGesture const &)*arg2);
67356     } catch (std::out_of_range& e) {
67357       {
67358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67359       };
67360     } catch (std::exception& e) {
67361       {
67362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67363       };
67364     } catch (Dali::DaliException e) {
67365       {
67366         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67367       };
67368     } catch (...) {
67369       {
67370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67371       };
67372     }
67373   }
67374
67375 }
67376
67377
67378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
67379   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67380   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
67381   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
67382
67383   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67384   arg2 = (Dali::SlotObserver *)jarg2;
67385   arg3 = (Dali::CallbackBase *)jarg3;
67386   {
67387     try {
67388       (arg1)->SignalConnected(arg2,arg3);
67389     } catch (std::out_of_range& e) {
67390       {
67391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67392       };
67393     } catch (std::exception& e) {
67394       {
67395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67396       };
67397     } catch (Dali::DaliException e) {
67398       {
67399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67400       };
67401     } catch (...) {
67402       {
67403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67404       };
67405     }
67406   }
67407
67408 }
67409
67410
67411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
67412   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67413   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
67414   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
67415
67416   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67417   arg2 = (Dali::SlotObserver *)jarg2;
67418   arg3 = (Dali::CallbackBase *)jarg3;
67419   {
67420     try {
67421       (arg1)->Dali::Toolkit::Internal::Control::SignalConnected(arg2,arg3);
67422     } catch (std::out_of_range& e) {
67423       {
67424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67425       };
67426     } catch (std::exception& e) {
67427       {
67428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67429       };
67430     } catch (Dali::DaliException e) {
67431       {
67432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67433       };
67434     } catch (...) {
67435       {
67436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67437       };
67438     }
67439   }
67440
67441 }
67442
67443
67444 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
67445   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67446   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
67447   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
67448
67449   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67450   arg2 = (Dali::SlotObserver *)jarg2;
67451   arg3 = (Dali::CallbackBase *)jarg3;
67452   {
67453     try {
67454       (arg1)->SignalDisconnected(arg2,arg3);
67455     } catch (std::out_of_range& e) {
67456       {
67457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67458       };
67459     } catch (std::exception& e) {
67460       {
67461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67462       };
67463     } catch (Dali::DaliException e) {
67464       {
67465         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67466       };
67467     } catch (...) {
67468       {
67469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67470       };
67471     }
67472   }
67473
67474 }
67475
67476
67477 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
67478   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67479   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
67480   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
67481
67482   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67483   arg2 = (Dali::SlotObserver *)jarg2;
67484   arg3 = (Dali::CallbackBase *)jarg3;
67485   {
67486     try {
67487       (arg1)->Dali::Toolkit::Internal::Control::SignalDisconnected(arg2,arg3);
67488     } catch (std::out_of_range& e) {
67489       {
67490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67491       };
67492     } catch (std::exception& e) {
67493       {
67494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67495       };
67496     } catch (Dali::DaliException e) {
67497       {
67498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67499       };
67500     } catch (...) {
67501       {
67502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67503       };
67504     }
67505   }
67506
67507 }
67508
67509
67510 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) {
67511   Dali::Toolkit::Internal::Control *obj = (Dali::Toolkit::Internal::Control *)objarg;
67512   SwigDirector_ViewImpl *director = dynamic_cast<SwigDirector_ViewImpl *>(obj);
67513   if (director) {
67514     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);
67515   }
67516 }
67517
67518
67519 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation__SWIG_0(void * jarg1) {
67520   void * jresult ;
67521   Dali::Toolkit::Control *arg1 = 0 ;
67522   Dali::Toolkit::Internal::Control *result = 0 ;
67523
67524   arg1 = (Dali::Toolkit::Control *)jarg1;
67525   if (!arg1) {
67526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
67527     return 0;
67528   }
67529   {
67530     try {
67531       result = (Dali::Toolkit::Internal::Control *) &Dali::Toolkit::Internal::GetImplementation(*arg1);
67532     } catch (std::out_of_range& e) {
67533       {
67534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67535       };
67536     } catch (std::exception& e) {
67537       {
67538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67539       };
67540     } catch (Dali::DaliException e) {
67541       {
67542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67543       };
67544     } catch (...) {
67545       {
67546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67547       };
67548     }
67549   }
67550
67551   jresult = (void *)result;
67552   return jresult;
67553 }
67554
67555
67556 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_STYLE_NAME_get() {
67557   int jresult ;
67558   int result;
67559
67560   result = (int)Dali::Toolkit::Control::Property::STYLE_NAME;
67561   jresult = (int)result;
67562   return jresult;
67563 }
67564
67565
67566 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_COLOR_get() {
67567   int jresult ;
67568   int result;
67569
67570   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_COLOR;
67571   jresult = (int)result;
67572   return jresult;
67573 }
67574
67575
67576 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_IMAGE_get() {
67577   int jresult ;
67578   int result;
67579
67580   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_IMAGE;
67581   jresult = (int)result;
67582   return jresult;
67583 }
67584
67585
67586 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_KEY_INPUT_FOCUS_get() {
67587   int jresult ;
67588   int result;
67589
67590   result = (int)Dali::Toolkit::Control::Property::KEY_INPUT_FOCUS;
67591   jresult = (int)result;
67592   return jresult;
67593 }
67594
67595
67596 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_get() {
67597   int jresult ;
67598   int result;
67599
67600   result = (int)Dali::Toolkit::Control::Property::BACKGROUND;
67601   jresult = (int)result;
67602   return jresult;
67603 }
67604
67605 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_MARGIN_get() {
67606   int jresult ;
67607   int result;
67608
67609   result = (int)Dali::Toolkit::Control::Property::MARGIN;
67610   jresult = (int)result;
67611   return jresult;
67612 }
67613
67614
67615 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_PADDING_get() {
67616   int jresult ;
67617   int result;
67618
67619   result = (int)Dali::Toolkit::Control::Property::PADDING;
67620   jresult = (int)result;
67621   return jresult;
67622 }
67623
67624 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_Property() {
67625   void * jresult ;
67626   Dali::Toolkit::Control::Property *result = 0 ;
67627
67628   {
67629     try {
67630       result = (Dali::Toolkit::Control::Property *)new Dali::Toolkit::Control::Property();
67631     } catch (std::out_of_range& e) {
67632       {
67633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67634       };
67635     } catch (std::exception& e) {
67636       {
67637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67638       };
67639     } catch (Dali::DaliException e) {
67640       {
67641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67642       };
67643     } catch (...) {
67644       {
67645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67646       };
67647     }
67648   }
67649
67650   jresult = (void *)result;
67651   return jresult;
67652 }
67653
67654
67655 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_Property(void * jarg1) {
67656   Dali::Toolkit::Control::Property *arg1 = (Dali::Toolkit::Control::Property *) 0 ;
67657
67658   arg1 = (Dali::Toolkit::Control::Property *)jarg1;
67659   {
67660     try {
67661       delete arg1;
67662     } catch (std::out_of_range& e) {
67663       {
67664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67665       };
67666     } catch (std::exception& e) {
67667       {
67668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67669       };
67670     } catch (Dali::DaliException e) {
67671       {
67672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67673       };
67674     } catch (...) {
67675       {
67676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67677       };
67678     }
67679   }
67680
67681 }
67682
67683
67684 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_KeyboardFocus() {
67685   void * jresult ;
67686   Dali::Toolkit::Control::KeyboardFocus *result = 0 ;
67687
67688   {
67689     try {
67690       result = (Dali::Toolkit::Control::KeyboardFocus *)new Dali::Toolkit::Control::KeyboardFocus();
67691     } catch (std::out_of_range& e) {
67692       {
67693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67694       };
67695     } catch (std::exception& e) {
67696       {
67697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67698       };
67699     } catch (Dali::DaliException e) {
67700       {
67701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67702       };
67703     } catch (...) {
67704       {
67705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67706       };
67707     }
67708   }
67709
67710   jresult = (void *)result;
67711   return jresult;
67712 }
67713
67714
67715 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_KeyboardFocus(void * jarg1) {
67716   Dali::Toolkit::Control::KeyboardFocus *arg1 = (Dali::Toolkit::Control::KeyboardFocus *) 0 ;
67717
67718   arg1 = (Dali::Toolkit::Control::KeyboardFocus *)jarg1;
67719   {
67720     try {
67721       delete arg1;
67722     } catch (std::out_of_range& e) {
67723       {
67724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67725       };
67726     } catch (std::exception& e) {
67727       {
67728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67729       };
67730     } catch (Dali::DaliException e) {
67731       {
67732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67733       };
67734     } catch (...) {
67735       {
67736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67737       };
67738     }
67739   }
67740
67741 }
67742
67743
67744 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_New() {
67745   void * jresult ;
67746   Dali::Toolkit::Control result;
67747
67748   {
67749     try {
67750       result = Dali::Toolkit::Control::New();
67751     } catch (std::out_of_range& e) {
67752       {
67753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67754       };
67755     } catch (std::exception& e) {
67756       {
67757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67758       };
67759     } catch (Dali::DaliException e) {
67760       {
67761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67762       };
67763     } catch (...) {
67764       {
67765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67766       };
67767     }
67768   }
67769
67770   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
67771   return jresult;
67772 }
67773
67774
67775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_0() {
67776   void * jresult ;
67777   Dali::Toolkit::Control *result = 0 ;
67778
67779   {
67780     try {
67781       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control();
67782     } catch (std::out_of_range& e) {
67783       {
67784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67785       };
67786     } catch (std::exception& e) {
67787       {
67788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67789       };
67790     } catch (Dali::DaliException e) {
67791       {
67792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67793       };
67794     } catch (...) {
67795       {
67796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67797       };
67798     }
67799   }
67800
67801   jresult = (void *)result;
67802   return jresult;
67803 }
67804
67805
67806 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_1(void * jarg1) {
67807   void * jresult ;
67808   Dali::Toolkit::Control *arg1 = 0 ;
67809   Dali::Toolkit::Control *result = 0 ;
67810
67811   arg1 = (Dali::Toolkit::Control *)jarg1;
67812   if (!arg1) {
67813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
67814     return 0;
67815   }
67816   {
67817     try {
67818       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control((Dali::Toolkit::Control const &)*arg1);
67819     } catch (std::out_of_range& e) {
67820       {
67821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67822       };
67823     } catch (std::exception& e) {
67824       {
67825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67826       };
67827     } catch (Dali::DaliException e) {
67828       {
67829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67830       };
67831     } catch (...) {
67832       {
67833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67834       };
67835     }
67836   }
67837
67838   jresult = (void *)result;
67839   return jresult;
67840 }
67841
67842
67843 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View(void * jarg1) {
67844   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67845
67846   arg1 = (Dali::Toolkit::Control *)jarg1;
67847   {
67848     try {
67849       delete arg1;
67850     } catch (std::out_of_range& e) {
67851       {
67852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67853       };
67854     } catch (std::exception& e) {
67855       {
67856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67857       };
67858     } catch (Dali::DaliException e) {
67859       {
67860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67861       };
67862     } catch (...) {
67863       {
67864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67865       };
67866     }
67867   }
67868
67869 }
67870
67871
67872 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_Assign(void * jarg1, void * jarg2) {
67873   void * jresult ;
67874   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67875   Dali::Toolkit::Control *arg2 = 0 ;
67876   Dali::Toolkit::Control *result = 0 ;
67877
67878   arg1 = (Dali::Toolkit::Control *)jarg1;
67879   arg2 = (Dali::Toolkit::Control *)jarg2;
67880   if (!arg2) {
67881     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
67882     return 0;
67883   }
67884   {
67885     try {
67886       result = (Dali::Toolkit::Control *) &(arg1)->operator =((Dali::Toolkit::Control const &)*arg2);
67887     } catch (std::out_of_range& e) {
67888       {
67889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67890       };
67891     } catch (std::exception& e) {
67892       {
67893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67894       };
67895     } catch (Dali::DaliException e) {
67896       {
67897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67898       };
67899     } catch (...) {
67900       {
67901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67902       };
67903     }
67904   }
67905
67906   jresult = (void *)result;
67907   return jresult;
67908 }
67909
67910
67911 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_DownCast(void * jarg1) {
67912   void * jresult ;
67913   Dali::BaseHandle arg1 ;
67914   Dali::BaseHandle *argp1 ;
67915   Dali::Toolkit::Control result;
67916
67917   argp1 = (Dali::BaseHandle *)jarg1;
67918   if (!argp1) {
67919     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67920     return 0;
67921   }
67922   arg1 = *argp1;
67923   {
67924     try {
67925       result = Dali::Toolkit::Control::DownCast(arg1);
67926     } catch (std::out_of_range& e) {
67927       {
67928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67929       };
67930     } catch (std::exception& e) {
67931       {
67932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67933       };
67934     } catch (Dali::DaliException e) {
67935       {
67936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67937       };
67938     } catch (...) {
67939       {
67940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67941       };
67942     }
67943   }
67944
67945   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
67946   return jresult;
67947 }
67948
67949
67950 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetKeyInputFocus(void * jarg1) {
67951   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67952
67953   arg1 = (Dali::Toolkit::Control *)jarg1;
67954   {
67955     try {
67956       (arg1)->SetKeyInputFocus();
67957     } catch (std::out_of_range& e) {
67958       {
67959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67960       };
67961     } catch (std::exception& e) {
67962       {
67963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67964       };
67965     } catch (Dali::DaliException e) {
67966       {
67967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67968       };
67969     } catch (...) {
67970       {
67971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67972       };
67973     }
67974   }
67975
67976 }
67977
67978
67979 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_View_HasKeyInputFocus(void * jarg1) {
67980   unsigned int jresult ;
67981   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67982   bool result;
67983
67984   arg1 = (Dali::Toolkit::Control *)jarg1;
67985   {
67986     try {
67987       result = (bool)(arg1)->HasKeyInputFocus();
67988     } catch (std::out_of_range& e) {
67989       {
67990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67991       };
67992     } catch (std::exception& e) {
67993       {
67994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67995       };
67996     } catch (Dali::DaliException e) {
67997       {
67998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67999       };
68000     } catch (...) {
68001       {
68002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68003       };
68004     }
68005   }
68006
68007   jresult = result;
68008   return jresult;
68009 }
68010
68011
68012 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearKeyInputFocus(void * jarg1) {
68013   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68014
68015   arg1 = (Dali::Toolkit::Control *)jarg1;
68016   {
68017     try {
68018       (arg1)->ClearKeyInputFocus();
68019     } catch (std::out_of_range& e) {
68020       {
68021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68022       };
68023     } catch (std::exception& e) {
68024       {
68025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68026       };
68027     } catch (Dali::DaliException e) {
68028       {
68029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68030       };
68031     } catch (...) {
68032       {
68033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68034       };
68035     }
68036   }
68037
68038 }
68039
68040
68041 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPinchGestureDetector(void * jarg1) {
68042   void * jresult ;
68043   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68044   Dali::PinchGestureDetector result;
68045
68046   arg1 = (Dali::Toolkit::Control *)jarg1;
68047   {
68048     try {
68049       result = ((Dali::Toolkit::Control const *)arg1)->GetPinchGestureDetector();
68050     } catch (std::out_of_range& e) {
68051       {
68052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68053       };
68054     } catch (std::exception& e) {
68055       {
68056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68057       };
68058     } catch (Dali::DaliException e) {
68059       {
68060         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68061       };
68062     } catch (...) {
68063       {
68064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68065       };
68066     }
68067   }
68068
68069   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
68070   return jresult;
68071 }
68072
68073
68074 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPanGestureDetector(void * jarg1) {
68075   void * jresult ;
68076   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68077   Dali::PanGestureDetector result;
68078
68079   arg1 = (Dali::Toolkit::Control *)jarg1;
68080   {
68081     try {
68082       result = ((Dali::Toolkit::Control const *)arg1)->GetPanGestureDetector();
68083     } catch (std::out_of_range& e) {
68084       {
68085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68086       };
68087     } catch (std::exception& e) {
68088       {
68089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68090       };
68091     } catch (Dali::DaliException e) {
68092       {
68093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68094       };
68095     } catch (...) {
68096       {
68097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68098       };
68099     }
68100   }
68101
68102   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
68103   return jresult;
68104 }
68105
68106
68107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetTapGestureDetector(void * jarg1) {
68108   void * jresult ;
68109   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68110   Dali::TapGestureDetector result;
68111
68112   arg1 = (Dali::Toolkit::Control *)jarg1;
68113   {
68114     try {
68115       result = ((Dali::Toolkit::Control const *)arg1)->GetTapGestureDetector();
68116     } catch (std::out_of_range& e) {
68117       {
68118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68119       };
68120     } catch (std::exception& e) {
68121       {
68122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68123       };
68124     } catch (Dali::DaliException e) {
68125       {
68126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68127       };
68128     } catch (...) {
68129       {
68130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68131       };
68132     }
68133   }
68134
68135   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
68136   return jresult;
68137 }
68138
68139
68140 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetLongPressGestureDetector(void * jarg1) {
68141   void * jresult ;
68142   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68143   Dali::LongPressGestureDetector result;
68144
68145   arg1 = (Dali::Toolkit::Control *)jarg1;
68146   {
68147     try {
68148       result = ((Dali::Toolkit::Control const *)arg1)->GetLongPressGestureDetector();
68149     } catch (std::out_of_range& e) {
68150       {
68151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68152       };
68153     } catch (std::exception& e) {
68154       {
68155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68156       };
68157     } catch (Dali::DaliException e) {
68158       {
68159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68160       };
68161     } catch (...) {
68162       {
68163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68164       };
68165     }
68166   }
68167
68168   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
68169   return jresult;
68170 }
68171
68172
68173 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetStyleName(void * jarg1, char * jarg2) {
68174   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68175   std::string *arg2 = 0 ;
68176
68177   arg1 = (Dali::Toolkit::Control *)jarg1;
68178   if (!jarg2) {
68179     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
68180     return ;
68181   }
68182   std::string arg2_str(jarg2);
68183   arg2 = &arg2_str;
68184   {
68185     try {
68186       (arg1)->SetStyleName((std::string const &)*arg2);
68187     } catch (std::out_of_range& e) {
68188       {
68189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68190       };
68191     } catch (std::exception& e) {
68192       {
68193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68194       };
68195     } catch (Dali::DaliException e) {
68196       {
68197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68198       };
68199     } catch (...) {
68200       {
68201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68202       };
68203     }
68204   }
68205
68206
68207   //argout typemap for const std::string&
68208
68209 }
68210
68211
68212 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_View_GetStyleName(void * jarg1) {
68213   char * jresult ;
68214   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68215   std::string *result = 0 ;
68216
68217   arg1 = (Dali::Toolkit::Control *)jarg1;
68218   {
68219     try {
68220       result = (std::string *) &((Dali::Toolkit::Control const *)arg1)->GetStyleName();
68221     } catch (std::out_of_range& e) {
68222       {
68223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68224       };
68225     } catch (std::exception& e) {
68226       {
68227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68228       };
68229     } catch (Dali::DaliException e) {
68230       {
68231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68232       };
68233     } catch (...) {
68234       {
68235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68236       };
68237     }
68238   }
68239
68240   jresult = SWIG_csharp_string_callback(result->c_str());
68241   return jresult;
68242 }
68243
68244
68245 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundColor(void * jarg1, void * jarg2) {
68246   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68247   Dali::Vector4 *arg2 = 0 ;
68248
68249   arg1 = (Dali::Toolkit::Control *)jarg1;
68250   arg2 = (Dali::Vector4 *)jarg2;
68251   if (!arg2) {
68252     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
68253     return ;
68254   }
68255   {
68256     try {
68257       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
68258     } catch (std::out_of_range& e) {
68259       {
68260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68261       };
68262     } catch (std::exception& e) {
68263       {
68264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68265       };
68266     } catch (Dali::DaliException e) {
68267       {
68268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68269       };
68270     } catch (...) {
68271       {
68272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68273       };
68274     }
68275   }
68276
68277 }
68278
68279
68280 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetBackgroundColor(void * jarg1) {
68281   void * jresult ;
68282   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68283   Dali::Vector4 result;
68284
68285   arg1 = (Dali::Toolkit::Control *)jarg1;
68286   {
68287     try {
68288       result = ((Dali::Toolkit::Control const *)arg1)->GetBackgroundColor();
68289     } catch (std::out_of_range& e) {
68290       {
68291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68292       };
68293     } catch (std::exception& e) {
68294       {
68295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68296       };
68297     } catch (Dali::DaliException e) {
68298       {
68299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68300       };
68301     } catch (...) {
68302       {
68303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68304       };
68305     }
68306   }
68307
68308   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
68309   return jresult;
68310 }
68311
68312
68313 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundImage(void * jarg1, void * jarg2) {
68314   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68315   Dali::Image arg2 ;
68316   Dali::Image *argp2 ;
68317
68318   arg1 = (Dali::Toolkit::Control *)jarg1;
68319   argp2 = (Dali::Image *)jarg2;
68320   if (!argp2) {
68321     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
68322     return ;
68323   }
68324   arg2 = *argp2;
68325   {
68326     try {
68327       (arg1)->SetBackgroundImage(arg2);
68328     } catch (std::out_of_range& e) {
68329       {
68330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68331       };
68332     } catch (std::exception& e) {
68333       {
68334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68335       };
68336     } catch (Dali::DaliException e) {
68337       {
68338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68339       };
68340     } catch (...) {
68341       {
68342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68343       };
68344     }
68345   }
68346
68347 }
68348
68349
68350 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearBackground(void * jarg1) {
68351   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68352
68353   arg1 = (Dali::Toolkit::Control *)jarg1;
68354   {
68355     try {
68356       (arg1)->ClearBackground();
68357     } catch (std::out_of_range& e) {
68358       {
68359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68360       };
68361     } catch (std::exception& e) {
68362       {
68363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68364       };
68365     } catch (Dali::DaliException e) {
68366       {
68367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68368       };
68369     } catch (...) {
68370       {
68371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68372       };
68373     }
68374   }
68375
68376 }
68377
68378
68379 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyEventSignal(void * jarg1) {
68380   void * jresult ;
68381   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68382   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
68383
68384   arg1 = (Dali::Toolkit::Control *)jarg1;
68385   {
68386     try {
68387       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
68388     } catch (std::out_of_range& e) {
68389       {
68390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68391       };
68392     } catch (std::exception& e) {
68393       {
68394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68395       };
68396     } catch (Dali::DaliException e) {
68397       {
68398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68399       };
68400     } catch (...) {
68401       {
68402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68403       };
68404     }
68405   }
68406
68407   jresult = (void *)result;
68408   return jresult;
68409 }
68410
68411
68412 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusGainedSignal(void * jarg1) {
68413   void * jresult ;
68414   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68415   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
68416
68417   arg1 = (Dali::Toolkit::Control *)jarg1;
68418   {
68419     try {
68420       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
68421     } catch (std::out_of_range& e) {
68422       {
68423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68424       };
68425     } catch (std::exception& e) {
68426       {
68427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68428       };
68429     } catch (Dali::DaliException e) {
68430       {
68431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68432       };
68433     } catch (...) {
68434       {
68435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68436       };
68437     }
68438   }
68439
68440   jresult = (void *)result;
68441   return jresult;
68442 }
68443
68444
68445 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusLostSignal(void * jarg1) {
68446   void * jresult ;
68447   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68448   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
68449
68450   arg1 = (Dali::Toolkit::Control *)jarg1;
68451   {
68452     try {
68453       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
68454     } catch (std::out_of_range& e) {
68455       {
68456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68457       };
68458     } catch (std::exception& e) {
68459       {
68460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68461       };
68462     } catch (Dali::DaliException e) {
68463       {
68464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68465       };
68466     } catch (...) {
68467       {
68468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68469       };
68470     }
68471   }
68472
68473   jresult = (void *)result;
68474   return jresult;
68475 }
68476
68477
68478 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_2(void * jarg1) {
68479   void * jresult ;
68480   Dali::Toolkit::Internal::Control *arg1 = 0 ;
68481   Dali::Toolkit::Control *result = 0 ;
68482
68483   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
68484   if (!arg1) {
68485     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
68486     return 0;
68487   }
68488   {
68489     try {
68490       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control(*arg1);
68491     } catch (std::out_of_range& e) {
68492       {
68493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68494       };
68495     } catch (std::exception& e) {
68496       {
68497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68498       };
68499     } catch (Dali::DaliException e) {
68500       {
68501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68502       };
68503     } catch (...) {
68504       {
68505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68506       };
68507     }
68508   }
68509
68510   jresult = (void *)result;
68511   return jresult;
68512 }
68513
68514 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_GetVisualResourceStatus(void * jarg1, int jarg2)
68515 {
68516   int jresult;
68517   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68518   arg1 = (Dali::Toolkit::Control *)jarg1;
68519
68520   if (!arg1) {
68521     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
68522     return 0;
68523   }
68524
68525   Dali::Property::Index arg2 = 0 ;
68526   arg2 = (Dali::Property::Index)jarg2;
68527
68528   Toolkit::Visual::ResourceStatus result;
68529   {
68530     try {
68531       result = arg1->GetVisualResourceStatus(arg2);
68532     } catch (std::out_of_range& e) {
68533       {
68534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68535       };
68536     } catch (std::exception& e) {
68537       {
68538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68539       };
68540     } catch (...) {
68541       {
68542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68543       };
68544     }
68545   }
68546   jresult = (int)(result);
68547   return jresult;
68548 }
68549
68550 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_CreateTransition(void * jarg1, void * jarg2)
68551 {
68552   void * jresult;
68553   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68554   arg1 = (Dali::Toolkit::Control *)jarg1;
68555
68556   Dali::Toolkit::Internal::Control& controlImpl = Dali::Toolkit::Internal::GetImplementation( *arg1 );
68557
68558   Dali::Toolkit::TransitionData *arg2 = 0 ;
68559   Dali::Animation result;
68560
68561   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
68562   if (!arg2) {
68563     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
68564     return 0;
68565   }
68566   {
68567     try {
68568       result = DevelControl::CreateTransition( controlImpl, (Dali::Toolkit::TransitionData const &)*arg2);
68569     } catch (std::out_of_range& e) {
68570       {
68571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68572       };
68573     } catch (std::exception& e) {
68574       {
68575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68576       };
68577     } catch (Dali::DaliException e) {
68578       {
68579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68580       };
68581     } catch (...) {
68582       {
68583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68584       };
68585     }
68586   }
68587
68588   jresult = new Dali::Animation((const Dali::Animation &)result);
68589   return jresult;
68590 }
68591
68592 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_DoAction(void * jarg1, int jarg2, int jarg3, void * jarg4 )
68593 {
68594   Dali::Toolkit::Control arg1;
68595   Dali::Toolkit::Control *argp1  = (Dali::Toolkit::Control *)jarg1;
68596
68597   if (!argp1) {
68598     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
68599   }
68600   arg1 = *argp1;
68601
68602   Dali::Property::Index arg2 = 0 ;
68603   arg2 = (Dali::Property::Index)jarg2;
68604
68605   Dali::Property::Index arg3 = 0 ;
68606   arg3 = (Dali::Property::Index)jarg3;
68607
68608   Dali::Property::Value arg4;
68609   arg4 = (Dali::Property::Value *)jarg4;
68610
68611   {
68612     try {
68613       DevelControl::DoAction(arg1, arg2, arg3, arg4);
68614     } catch (std::out_of_range& e) {
68615       {
68616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68617       };
68618     } catch (std::exception& e) {
68619       {
68620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68621       };
68622     } catch (...) {
68623       {
68624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68625       };
68626     }
68627   }
68628
68629
68630 }
68631
68632 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetLayout__SWIG_0(void * jarg1) {
68633   void * jresult ;
68634   Dali::Toolkit::Internal::Control *arg1 = 0 ;
68635   Dali::Toolkit::LayoutItem result;
68636
68637   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
68638   if (!arg1) {
68639     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
68640     return 0;
68641   }
68642   {
68643     try {
68644       result = Dali::Toolkit::DevelControl::GetLayout(*arg1);
68645     } catch (std::out_of_range& e) {
68646       {
68647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68648       };
68649     } catch (std::exception& e) {
68650       {
68651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68652       };
68653     } catch (...) {
68654       {
68655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68656       };
68657     }
68658   }
68659   jresult = new Dali::Toolkit::LayoutItem((const Dali::Toolkit::LayoutItem &)result);
68660   return jresult;
68661 }
68662
68663
68664 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetLayout__SWIG_1(void * jarg1) {
68665   void * jresult ;
68666   Dali::Toolkit::Control arg1 ;
68667   Dali::Toolkit::Control *argp1 ;
68668   Dali::Toolkit::LayoutItem result;
68669
68670   argp1 = (Dali::Toolkit::Control *)jarg1;
68671   if (!argp1) {
68672     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
68673     return 0;
68674   }
68675   arg1 = *argp1;
68676   {
68677     try {
68678       result = Dali::Toolkit::DevelControl::GetLayout(arg1);
68679     } catch (std::out_of_range& e) {
68680       {
68681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68682       };
68683     } catch (std::exception& e) {
68684       {
68685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68686       };
68687     } catch (...) {
68688       {
68689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68690       };
68691     }
68692   }
68693   jresult = new Dali::Toolkit::LayoutItem((const Dali::Toolkit::LayoutItem &)result);
68694   return jresult;
68695 }
68696
68697 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetLayout__SWIG_0(void * jarg1, void * jarg2) {
68698   Dali::Toolkit::Internal::Control *arg1 = 0 ;
68699   Dali::Toolkit::LayoutItem arg2 ;
68700   Dali::Toolkit::LayoutItem *argp2 ;
68701
68702   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
68703   if (!arg1) {
68704     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
68705     return ;
68706   }
68707   argp2 = (Dali::Toolkit::LayoutItem *)jarg2;
68708   if (!argp2) {
68709     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutItem", 0);
68710     return ;
68711   }
68712   arg2 = *argp2;
68713   {
68714     try {
68715       Dali::Toolkit::DevelControl::SetLayout(*arg1,arg2);
68716     } catch (std::out_of_range& e) {
68717       {
68718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68719       };
68720     } catch (std::exception& e) {
68721       {
68722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68723       };
68724     } catch (...) {
68725       {
68726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68727       };
68728     }
68729   }
68730 }
68731
68732
68733 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetLayout__SWIG_1(void * jarg1, void * jarg2) {
68734   Dali::Toolkit::Control arg1 ;
68735   Dali::Toolkit::LayoutItem arg2 ;
68736   Dali::Toolkit::Control *argp1 ;
68737   Dali::Toolkit::LayoutItem *argp2 ;
68738
68739   argp1 = (Dali::Toolkit::Control *)jarg1;
68740   if (!argp1) {
68741     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
68742     return ;
68743   }
68744   arg1 = *argp1;
68745   argp2 = (Dali::Toolkit::LayoutItem *)jarg2;
68746   if (!argp2) {
68747     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutItem", 0);
68748     return ;
68749   }
68750   arg2 = *argp2;
68751   {
68752     try {
68753       Dali::Toolkit::DevelControl::SetLayout(arg1,arg2);
68754     } catch (std::out_of_range& e) {
68755       {
68756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68757       };
68758     } catch (std::exception& e) {
68759       {
68760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68761       };
68762     } catch (...) {
68763       {
68764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68765       };
68766     }
68767   }
68768 }
68769
68770 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceReadySignal(void * jarg1) {
68771   void * jresult ;
68772   Dali::Toolkit::Control *arg1 = 0 ;
68773   Dali::Toolkit::Control::ResourceReadySignalType *result = 0 ;
68774
68775   arg1 = (Dali::Toolkit::Control *)jarg1;
68776   if (!arg1) {
68777     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
68778     return 0;
68779   }
68780   {
68781     try {
68782       result = (Dali::Toolkit::Control::ResourceReadySignalType *) &arg1->ResourceReadySignal();
68783     } catch (std::out_of_range& e) {
68784       {
68785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68786       };
68787     } catch (std::exception& e) {
68788       {
68789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68790       };
68791     } catch (Dali::DaliException e) {
68792       {
68793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68794       };
68795     } catch (...) {
68796       {
68797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68798       };
68799     }
68800   }
68801
68802   jresult = (void *)result;
68803   return jresult;
68804 }
68805
68806
68807 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsResourceReady(void * jarg1) {
68808   unsigned int jresult ;
68809   Dali::Toolkit::Control *arg1 = 0 ;
68810   bool result;
68811
68812   arg1 = (Dali::Toolkit::Control *)jarg1;
68813   if (!arg1) {
68814     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
68815     return 0;
68816   }
68817   {
68818     try {
68819       result = (bool)arg1->IsResourceReady();
68820     } catch (std::out_of_range& e) {
68821       {
68822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68823       };
68824     } catch (std::exception& e) {
68825       {
68826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68827       };
68828     } catch (Dali::DaliException e) {
68829       {
68830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68831       };
68832     } catch (...) {
68833       {
68834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68835       };
68836     }
68837   }
68838
68839   jresult = result;
68840   return jresult;
68841 }
68842
68843
68844 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusManager() {
68845   void * jresult ;
68846   Dali::Toolkit::KeyInputFocusManager *result = 0 ;
68847
68848   {
68849     try {
68850       result = (Dali::Toolkit::KeyInputFocusManager *)new Dali::Toolkit::KeyInputFocusManager();
68851     } catch (std::out_of_range& e) {
68852       {
68853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68854       };
68855     } catch (std::exception& e) {
68856       {
68857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68858       };
68859     } catch (Dali::DaliException e) {
68860       {
68861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68862       };
68863     } catch (...) {
68864       {
68865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68866       };
68867     }
68868   }
68869
68870   jresult = (void *)result;
68871   return jresult;
68872 }
68873
68874
68875 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusManager(void * jarg1) {
68876   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68877
68878   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68879   {
68880     try {
68881       delete arg1;
68882     } catch (std::out_of_range& e) {
68883       {
68884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68885       };
68886     } catch (std::exception& e) {
68887       {
68888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68889       };
68890     } catch (Dali::DaliException e) {
68891       {
68892         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68893       };
68894     } catch (...) {
68895       {
68896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68897       };
68898     }
68899   }
68900
68901 }
68902
68903
68904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_Get() {
68905   void * jresult ;
68906   Dali::Toolkit::KeyInputFocusManager result;
68907
68908   {
68909     try {
68910       result = Dali::Toolkit::KeyInputFocusManager::Get();
68911     } catch (std::out_of_range& e) {
68912       {
68913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68914       };
68915     } catch (std::exception& e) {
68916       {
68917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68918       };
68919     } catch (Dali::DaliException e) {
68920       {
68921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68922       };
68923     } catch (...) {
68924       {
68925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68926       };
68927     }
68928   }
68929
68930   jresult = new Dali::Toolkit::KeyInputFocusManager((const Dali::Toolkit::KeyInputFocusManager &)result);
68931   return jresult;
68932 }
68933
68934
68935 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SetFocus(void * jarg1, void * jarg2) {
68936   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68937   Dali::Toolkit::Control arg2 ;
68938   Dali::Toolkit::Control *argp2 ;
68939
68940   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68941   argp2 = (Dali::Toolkit::Control *)jarg2;
68942   if (!argp2) {
68943     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
68944     return ;
68945   }
68946   arg2 = *argp2;
68947   {
68948     try {
68949       (arg1)->SetFocus(arg2);
68950     } catch (std::out_of_range& e) {
68951       {
68952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68953       };
68954     } catch (std::exception& e) {
68955       {
68956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68957       };
68958     } catch (Dali::DaliException e) {
68959       {
68960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68961       };
68962     } catch (...) {
68963       {
68964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68965       };
68966     }
68967   }
68968
68969 }
68970
68971
68972 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_GetCurrentFocusControl(void * jarg1) {
68973   void * jresult ;
68974   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68975   Dali::Toolkit::Control result;
68976
68977   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68978   {
68979     try {
68980       result = ((Dali::Toolkit::KeyInputFocusManager const *)arg1)->GetCurrentFocusControl();
68981     } catch (std::out_of_range& e) {
68982       {
68983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68984       };
68985     } catch (std::exception& e) {
68986       {
68987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68988       };
68989     } catch (Dali::DaliException e) {
68990       {
68991         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68992       };
68993     } catch (...) {
68994       {
68995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68996       };
68997     }
68998   }
68999
69000   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
69001   return jresult;
69002 }
69003
69004
69005 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_RemoveFocus(void * jarg1, void * jarg2) {
69006   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
69007   Dali::Toolkit::Control arg2 ;
69008   Dali::Toolkit::Control *argp2 ;
69009
69010   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
69011   argp2 = (Dali::Toolkit::Control *)jarg2;
69012   if (!argp2) {
69013     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
69014     return ;
69015   }
69016   arg2 = *argp2;
69017   {
69018     try {
69019       (arg1)->RemoveFocus(arg2);
69020     } catch (std::out_of_range& e) {
69021       {
69022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69023       };
69024     } catch (std::exception& e) {
69025       {
69026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69027       };
69028     } catch (Dali::DaliException e) {
69029       {
69030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69031       };
69032     } catch (...) {
69033       {
69034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69035       };
69036     }
69037   }
69038
69039 }
69040
69041
69042 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_KeyInputFocusChangedSignal(void * jarg1) {
69043   void * jresult ;
69044   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
69045   Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *result = 0 ;
69046
69047   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
69048   {
69049     try {
69050       result = (Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *) &(arg1)->KeyInputFocusChangedSignal();
69051     } catch (std::out_of_range& e) {
69052       {
69053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69054       };
69055     } catch (std::exception& e) {
69056       {
69057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69058       };
69059     } catch (Dali::DaliException e) {
69060       {
69061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69062       };
69063     } catch (...) {
69064       {
69065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69066       };
69067     }
69068   }
69069
69070   jresult = (void *)result;
69071   return jresult;
69072 }
69073
69074
69075 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_0() {
69076   void * jresult ;
69077   Dali::Toolkit::Alignment::Padding *result = 0 ;
69078
69079   {
69080     try {
69081       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding();
69082     } catch (std::out_of_range& e) {
69083       {
69084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69085       };
69086     } catch (std::exception& e) {
69087       {
69088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69089       };
69090     } catch (Dali::DaliException e) {
69091       {
69092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69093       };
69094     } catch (...) {
69095       {
69096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69097       };
69098     }
69099   }
69100
69101   jresult = (void *)result;
69102   return jresult;
69103 }
69104
69105
69106 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
69107   void * jresult ;
69108   float arg1 ;
69109   float arg2 ;
69110   float arg3 ;
69111   float arg4 ;
69112   Dali::Toolkit::Alignment::Padding *result = 0 ;
69113
69114   arg1 = (float)jarg1;
69115   arg2 = (float)jarg2;
69116   arg3 = (float)jarg3;
69117   arg4 = (float)jarg4;
69118   {
69119     try {
69120       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding(arg1,arg2,arg3,arg4);
69121     } catch (std::out_of_range& e) {
69122       {
69123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69124       };
69125     } catch (std::exception& e) {
69126       {
69127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69128       };
69129     } catch (Dali::DaliException e) {
69130       {
69131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69132       };
69133     } catch (...) {
69134       {
69135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69136       };
69137     }
69138   }
69139
69140   jresult = (void *)result;
69141   return jresult;
69142 }
69143
69144
69145 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_set(void * jarg1, float jarg2) {
69146   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
69147   float arg2 ;
69148
69149   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
69150   arg2 = (float)jarg2;
69151   if (arg1) (arg1)->left = arg2;
69152 }
69153
69154
69155 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_get(void * jarg1) {
69156   float jresult ;
69157   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
69158   float result;
69159
69160   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
69161   result = (float) ((arg1)->left);
69162   jresult = result;
69163   return jresult;
69164 }
69165
69166
69167 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_set(void * jarg1, float jarg2) {
69168   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
69169   float arg2 ;
69170
69171   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
69172   arg2 = (float)jarg2;
69173   if (arg1) (arg1)->right = arg2;
69174 }
69175
69176
69177 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_get(void * jarg1) {
69178   float jresult ;
69179   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
69180   float result;
69181
69182   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
69183   result = (float) ((arg1)->right);
69184   jresult = result;
69185   return jresult;
69186 }
69187
69188
69189 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_set(void * jarg1, float jarg2) {
69190   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
69191   float arg2 ;
69192
69193   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
69194   arg2 = (float)jarg2;
69195   if (arg1) (arg1)->top = arg2;
69196 }
69197
69198
69199 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_get(void * jarg1) {
69200   float jresult ;
69201   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
69202   float result;
69203
69204   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
69205   result = (float) ((arg1)->top);
69206   jresult = result;
69207   return jresult;
69208 }
69209
69210
69211 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_set(void * jarg1, float jarg2) {
69212   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
69213   float arg2 ;
69214
69215   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
69216   arg2 = (float)jarg2;
69217   if (arg1) (arg1)->bottom = arg2;
69218 }
69219
69220
69221 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_get(void * jarg1) {
69222   float jresult ;
69223   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
69224   float result;
69225
69226   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
69227   result = (float) ((arg1)->bottom);
69228   jresult = result;
69229   return jresult;
69230 }
69231
69232
69233 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment_Padding(void * jarg1) {
69234   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
69235
69236   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
69237   {
69238     try {
69239       delete arg1;
69240     } catch (std::out_of_range& e) {
69241       {
69242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69243       };
69244     } catch (std::exception& e) {
69245       {
69246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69247       };
69248     } catch (Dali::DaliException e) {
69249       {
69250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69251       };
69252     } catch (...) {
69253       {
69254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69255       };
69256     }
69257   }
69258
69259 }
69260
69261
69262 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_0() {
69263   void * jresult ;
69264   Dali::Toolkit::Alignment *result = 0 ;
69265
69266   {
69267     try {
69268       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment();
69269     } catch (std::out_of_range& e) {
69270       {
69271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69272       };
69273     } catch (std::exception& e) {
69274       {
69275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69276       };
69277     } catch (Dali::DaliException e) {
69278       {
69279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69280       };
69281     } catch (...) {
69282       {
69283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69284       };
69285     }
69286   }
69287
69288   jresult = (void *)result;
69289   return jresult;
69290 }
69291
69292
69293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_0(int jarg1, int jarg2) {
69294   void * jresult ;
69295   Dali::Toolkit::Alignment::Type arg1 ;
69296   Dali::Toolkit::Alignment::Type arg2 ;
69297   Dali::Toolkit::Alignment result;
69298
69299   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
69300   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
69301   {
69302     try {
69303       result = Dali::Toolkit::Alignment::New(arg1,arg2);
69304     } catch (std::out_of_range& e) {
69305       {
69306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69307       };
69308     } catch (std::exception& e) {
69309       {
69310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69311       };
69312     } catch (Dali::DaliException e) {
69313       {
69314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69315       };
69316     } catch (...) {
69317       {
69318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69319       };
69320     }
69321   }
69322
69323   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
69324   return jresult;
69325 }
69326
69327
69328 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_1(int jarg1) {
69329   void * jresult ;
69330   Dali::Toolkit::Alignment::Type arg1 ;
69331   Dali::Toolkit::Alignment result;
69332
69333   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
69334   {
69335     try {
69336       result = Dali::Toolkit::Alignment::New(arg1);
69337     } catch (std::out_of_range& e) {
69338       {
69339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69340       };
69341     } catch (std::exception& e) {
69342       {
69343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69344       };
69345     } catch (Dali::DaliException e) {
69346       {
69347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69348       };
69349     } catch (...) {
69350       {
69351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69352       };
69353     }
69354   }
69355
69356   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
69357   return jresult;
69358 }
69359
69360
69361 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_2() {
69362   void * jresult ;
69363   Dali::Toolkit::Alignment result;
69364
69365   {
69366     try {
69367       result = Dali::Toolkit::Alignment::New();
69368     } catch (std::out_of_range& e) {
69369       {
69370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69371       };
69372     } catch (std::exception& e) {
69373       {
69374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69375       };
69376     } catch (Dali::DaliException e) {
69377       {
69378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69379       };
69380     } catch (...) {
69381       {
69382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69383       };
69384     }
69385   }
69386
69387   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
69388   return jresult;
69389 }
69390
69391
69392 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_1(void * jarg1) {
69393   void * jresult ;
69394   Dali::Toolkit::Alignment *arg1 = 0 ;
69395   Dali::Toolkit::Alignment *result = 0 ;
69396
69397   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69398   if (!arg1) {
69399     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
69400     return 0;
69401   }
69402   {
69403     try {
69404       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment((Dali::Toolkit::Alignment const &)*arg1);
69405     } catch (std::out_of_range& e) {
69406       {
69407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69408       };
69409     } catch (std::exception& e) {
69410       {
69411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69412       };
69413     } catch (Dali::DaliException e) {
69414       {
69415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69416       };
69417     } catch (...) {
69418       {
69419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69420       };
69421     }
69422   }
69423
69424   jresult = (void *)result;
69425   return jresult;
69426 }
69427
69428
69429 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment(void * jarg1) {
69430   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69431
69432   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69433   {
69434     try {
69435       delete arg1;
69436     } catch (std::out_of_range& e) {
69437       {
69438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69439       };
69440     } catch (std::exception& e) {
69441       {
69442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69443       };
69444     } catch (Dali::DaliException e) {
69445       {
69446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69447       };
69448     } catch (...) {
69449       {
69450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69451       };
69452     }
69453   }
69454
69455 }
69456
69457
69458 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_DownCast(void * jarg1) {
69459   void * jresult ;
69460   Dali::BaseHandle arg1 ;
69461   Dali::BaseHandle *argp1 ;
69462   Dali::Toolkit::Alignment result;
69463
69464   argp1 = (Dali::BaseHandle *)jarg1;
69465   if (!argp1) {
69466     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
69467     return 0;
69468   }
69469   arg1 = *argp1;
69470   {
69471     try {
69472       result = Dali::Toolkit::Alignment::DownCast(arg1);
69473     } catch (std::out_of_range& e) {
69474       {
69475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69476       };
69477     } catch (std::exception& e) {
69478       {
69479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69480       };
69481     } catch (Dali::DaliException e) {
69482       {
69483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69484       };
69485     } catch (...) {
69486       {
69487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69488       };
69489     }
69490   }
69491
69492   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
69493   return jresult;
69494 }
69495
69496
69497 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetAlignmentType(void * jarg1, int jarg2) {
69498   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69499   Dali::Toolkit::Alignment::Type arg2 ;
69500
69501   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69502   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
69503   {
69504     try {
69505       (arg1)->SetAlignmentType(arg2);
69506     } catch (std::out_of_range& e) {
69507       {
69508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69509       };
69510     } catch (std::exception& e) {
69511       {
69512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69513       };
69514     } catch (Dali::DaliException e) {
69515       {
69516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69517       };
69518     } catch (...) {
69519       {
69520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69521       };
69522     }
69523   }
69524
69525 }
69526
69527
69528 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetAlignmentType(void * jarg1) {
69529   int jresult ;
69530   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69531   Dali::Toolkit::Alignment::Type result;
69532
69533   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69534   {
69535     try {
69536       result = (Dali::Toolkit::Alignment::Type)((Dali::Toolkit::Alignment const *)arg1)->GetAlignmentType();
69537     } catch (std::out_of_range& e) {
69538       {
69539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69540       };
69541     } catch (std::exception& e) {
69542       {
69543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69544       };
69545     } catch (Dali::DaliException e) {
69546       {
69547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69548       };
69549     } catch (...) {
69550       {
69551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69552       };
69553     }
69554   }
69555
69556   jresult = (int)result;
69557   return jresult;
69558 }
69559
69560
69561 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetScaling(void * jarg1, int jarg2) {
69562   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69563   Dali::Toolkit::Alignment::Scaling arg2 ;
69564
69565   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69566   arg2 = (Dali::Toolkit::Alignment::Scaling)jarg2;
69567   {
69568     try {
69569       (arg1)->SetScaling(arg2);
69570     } catch (std::out_of_range& e) {
69571       {
69572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69573       };
69574     } catch (std::exception& e) {
69575       {
69576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69577       };
69578     } catch (Dali::DaliException e) {
69579       {
69580         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69581       };
69582     } catch (...) {
69583       {
69584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69585       };
69586     }
69587   }
69588
69589 }
69590
69591
69592 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetScaling(void * jarg1) {
69593   int jresult ;
69594   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69595   Dali::Toolkit::Alignment::Scaling result;
69596
69597   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69598   {
69599     try {
69600       result = (Dali::Toolkit::Alignment::Scaling)((Dali::Toolkit::Alignment const *)arg1)->GetScaling();
69601     } catch (std::out_of_range& e) {
69602       {
69603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69604       };
69605     } catch (std::exception& e) {
69606       {
69607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69608       };
69609     } catch (Dali::DaliException e) {
69610       {
69611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69612       };
69613     } catch (...) {
69614       {
69615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69616       };
69617     }
69618   }
69619
69620   jresult = (int)result;
69621   return jresult;
69622 }
69623
69624
69625 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetPadding(void * jarg1, void * jarg2) {
69626   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69627   Dali::Toolkit::Alignment::Padding *arg2 = 0 ;
69628
69629   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69630   arg2 = (Dali::Toolkit::Alignment::Padding *)jarg2;
69631   if (!arg2) {
69632     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment::Padding const & type is null", 0);
69633     return ;
69634   }
69635   {
69636     try {
69637       (arg1)->SetPadding((Dali::Toolkit::Alignment::Padding const &)*arg2);
69638     } catch (std::out_of_range& e) {
69639       {
69640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69641       };
69642     } catch (std::exception& e) {
69643       {
69644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69645       };
69646     } catch (Dali::DaliException e) {
69647       {
69648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69649       };
69650     } catch (...) {
69651       {
69652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69653       };
69654     }
69655   }
69656
69657 }
69658
69659
69660 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_GetPadding(void * jarg1) {
69661   void * jresult ;
69662   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69663   Dali::Toolkit::Alignment::Padding *result = 0 ;
69664
69665   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69666   {
69667     try {
69668       result = (Dali::Toolkit::Alignment::Padding *) &((Dali::Toolkit::Alignment const *)arg1)->GetPadding();
69669     } catch (std::out_of_range& e) {
69670       {
69671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69672       };
69673     } catch (std::exception& e) {
69674       {
69675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69676       };
69677     } catch (Dali::DaliException e) {
69678       {
69679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69680       };
69681     } catch (...) {
69682       {
69683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69684       };
69685     }
69686   }
69687
69688   jresult = (void *)result;
69689   return jresult;
69690 }
69691
69692
69693 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_Assign(void * jarg1, void * jarg2) {
69694   void * jresult ;
69695   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69696   Dali::Toolkit::Alignment *arg2 = 0 ;
69697   Dali::Toolkit::Alignment *result = 0 ;
69698
69699   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69700   arg2 = (Dali::Toolkit::Alignment *)jarg2;
69701   if (!arg2) {
69702     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
69703     return 0;
69704   }
69705   {
69706     try {
69707       result = (Dali::Toolkit::Alignment *) &(arg1)->operator =((Dali::Toolkit::Alignment const &)*arg2);
69708     } catch (std::out_of_range& e) {
69709       {
69710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69711       };
69712     } catch (std::exception& e) {
69713       {
69714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69715       };
69716     } catch (Dali::DaliException e) {
69717       {
69718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69719       };
69720     } catch (...) {
69721       {
69722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69723       };
69724     }
69725   }
69726
69727   jresult = (void *)result;
69728   return jresult;
69729 }
69730
69731
69732 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_DISABLED_get() {
69733   int jresult ;
69734   int result;
69735
69736   result = (int)Dali::Toolkit::Button::Property::DISABLED;
69737   jresult = (int)result;
69738   return jresult;
69739 }
69740
69741
69742 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_AUTO_REPEATING_get() {
69743   int jresult ;
69744   int result;
69745
69746   result = (int)Dali::Toolkit::Button::Property::AUTO_REPEATING;
69747   jresult = (int)result;
69748   return jresult;
69749 }
69750
69751
69752 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_INITIAL_AUTO_REPEATING_DELAY_get() {
69753   int jresult ;
69754   int result;
69755
69756   result = (int)Dali::Toolkit::Button::Property::INITIAL_AUTO_REPEATING_DELAY;
69757   jresult = (int)result;
69758   return jresult;
69759 }
69760
69761
69762 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_NEXT_AUTO_REPEATING_DELAY_get() {
69763   int jresult ;
69764   int result;
69765
69766   result = (int)Dali::Toolkit::Button::Property::NEXT_AUTO_REPEATING_DELAY;
69767   jresult = (int)result;
69768   return jresult;
69769 }
69770
69771
69772 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_TOGGLABLE_get() {
69773   int jresult ;
69774   int result;
69775
69776   result = (int)Dali::Toolkit::Button::Property::TOGGLABLE;
69777   jresult = (int)result;
69778   return jresult;
69779 }
69780
69781
69782 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_get() {
69783   int jresult ;
69784   int result;
69785
69786   result = (int)Dali::Toolkit::Button::Property::SELECTED;
69787   jresult = (int)result;
69788   return jresult;
69789 }
69790
69791
69792 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_UNSELECTED_COLOR_get() {
69793   int jresult ;
69794   int result;
69795
69796   result = (int)Dali::Toolkit::Button::Property::UNSELECTED_COLOR;
69797   jresult = (int)result;
69798   return jresult;
69799 }
69800
69801
69802 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_COLOR_get() {
69803   int jresult ;
69804   int result;
69805
69806   result = (int)Dali::Toolkit::Button::Property::SELECTED_COLOR;
69807   jresult = (int)result;
69808   return jresult;
69809 }
69810
69811
69812 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_get() {
69813   int jresult ;
69814   int result;
69815
69816   result = (int)Dali::Toolkit::Button::Property::LABEL;
69817   jresult = (int)result;
69818   return jresult;
69819 }
69820
69821
69822 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_TEXT_get() {
69823   int jresult ;
69824   int result;
69825
69826   result = (int)Dali::Toolkit::Button::Property::LABEL_TEXT;
69827   jresult = (int)result;
69828   return jresult;
69829 }
69830
69831
69832 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button_Property() {
69833   void * jresult ;
69834   Dali::Toolkit::Button::Property *result = 0 ;
69835
69836   {
69837     try {
69838       result = (Dali::Toolkit::Button::Property *)new Dali::Toolkit::Button::Property();
69839     } catch (std::out_of_range& e) {
69840       {
69841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69842       };
69843     } catch (std::exception& e) {
69844       {
69845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69846       };
69847     } catch (Dali::DaliException e) {
69848       {
69849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69850       };
69851     } catch (...) {
69852       {
69853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69854       };
69855     }
69856   }
69857
69858   jresult = (void *)result;
69859   return jresult;
69860 }
69861
69862
69863 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button_Property(void * jarg1) {
69864   Dali::Toolkit::Button::Property *arg1 = (Dali::Toolkit::Button::Property *) 0 ;
69865
69866   arg1 = (Dali::Toolkit::Button::Property *)jarg1;
69867   {
69868     try {
69869       delete arg1;
69870     } catch (std::out_of_range& e) {
69871       {
69872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69873       };
69874     } catch (std::exception& e) {
69875       {
69876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69877       };
69878     } catch (Dali::DaliException e) {
69879       {
69880         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69881       };
69882     } catch (...) {
69883       {
69884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69885       };
69886     }
69887   }
69888
69889 }
69890
69891
69892 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_0() {
69893   void * jresult ;
69894   Dali::Toolkit::Button *result = 0 ;
69895
69896   {
69897     try {
69898       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button();
69899     } catch (std::out_of_range& e) {
69900       {
69901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69902       };
69903     } catch (std::exception& e) {
69904       {
69905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69906       };
69907     } catch (Dali::DaliException e) {
69908       {
69909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69910       };
69911     } catch (...) {
69912       {
69913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69914       };
69915     }
69916   }
69917
69918   jresult = (void *)result;
69919   return jresult;
69920 }
69921
69922
69923 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_1(void * jarg1) {
69924   void * jresult ;
69925   Dali::Toolkit::Button *arg1 = 0 ;
69926   Dali::Toolkit::Button *result = 0 ;
69927
69928   arg1 = (Dali::Toolkit::Button *)jarg1;
69929   if (!arg1) {
69930     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
69931     return 0;
69932   }
69933   {
69934     try {
69935       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button((Dali::Toolkit::Button const &)*arg1);
69936     } catch (std::out_of_range& e) {
69937       {
69938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69939       };
69940     } catch (std::exception& e) {
69941       {
69942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69943       };
69944     } catch (Dali::DaliException e) {
69945       {
69946         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69947       };
69948     } catch (...) {
69949       {
69950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69951       };
69952     }
69953   }
69954
69955   jresult = (void *)result;
69956   return jresult;
69957 }
69958
69959
69960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_Assign(void * jarg1, void * jarg2) {
69961   void * jresult ;
69962   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69963   Dali::Toolkit::Button *arg2 = 0 ;
69964   Dali::Toolkit::Button *result = 0 ;
69965
69966   arg1 = (Dali::Toolkit::Button *)jarg1;
69967   arg2 = (Dali::Toolkit::Button *)jarg2;
69968   if (!arg2) {
69969     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
69970     return 0;
69971   }
69972   {
69973     try {
69974       result = (Dali::Toolkit::Button *) &(arg1)->operator =((Dali::Toolkit::Button const &)*arg2);
69975     } catch (std::out_of_range& e) {
69976       {
69977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69978       };
69979     } catch (std::exception& e) {
69980       {
69981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69982       };
69983     } catch (Dali::DaliException e) {
69984       {
69985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69986       };
69987     } catch (...) {
69988       {
69989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69990       };
69991     }
69992   }
69993
69994   jresult = (void *)result;
69995   return jresult;
69996 }
69997
69998
69999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_DownCast(void * jarg1) {
70000   void * jresult ;
70001   Dali::BaseHandle arg1 ;
70002   Dali::BaseHandle *argp1 ;
70003   Dali::Toolkit::Button result;
70004
70005   argp1 = (Dali::BaseHandle *)jarg1;
70006   if (!argp1) {
70007     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
70008     return 0;
70009   }
70010   arg1 = *argp1;
70011   {
70012     try {
70013       result = Dali::Toolkit::Button::DownCast(arg1);
70014     } catch (std::out_of_range& e) {
70015       {
70016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70017       };
70018     } catch (std::exception& e) {
70019       {
70020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70021       };
70022     } catch (Dali::DaliException e) {
70023       {
70024         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70025       };
70026     } catch (...) {
70027       {
70028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70029       };
70030     }
70031   }
70032
70033   jresult = new Dali::Toolkit::Button((const Dali::Toolkit::Button &)result);
70034   return jresult;
70035 }
70036
70037
70038 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button(void * jarg1) {
70039   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70040
70041   arg1 = (Dali::Toolkit::Button *)jarg1;
70042   {
70043     try {
70044       delete arg1;
70045     } catch (std::out_of_range& e) {
70046       {
70047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70048       };
70049     } catch (std::exception& e) {
70050       {
70051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70052       };
70053     } catch (Dali::DaliException e) {
70054       {
70055         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70056       };
70057     } catch (...) {
70058       {
70059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70060       };
70061     }
70062   }
70063
70064 }
70065
70066
70067 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsDisabled(void * jarg1) {
70068   unsigned int jresult ;
70069   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70070   bool result;
70071
70072   arg1 = (Dali::Toolkit::Button *)jarg1;
70073   {
70074     try {
70075       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsDisabled();
70076     } catch (std::out_of_range& e) {
70077       {
70078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70079       };
70080     } catch (std::exception& e) {
70081       {
70082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70083       };
70084     } catch (Dali::DaliException e) {
70085       {
70086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70087       };
70088     } catch (...) {
70089       {
70090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70091       };
70092     }
70093   }
70094
70095   jresult = result;
70096   return jresult;
70097 }
70098
70099
70100 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsAutoRepeating(void * jarg1) {
70101   unsigned int jresult ;
70102   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70103   bool result;
70104
70105   arg1 = (Dali::Toolkit::Button *)jarg1;
70106   {
70107     try {
70108       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsAutoRepeating();
70109     } catch (std::out_of_range& e) {
70110       {
70111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70112       };
70113     } catch (std::exception& e) {
70114       {
70115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70116       };
70117     } catch (Dali::DaliException e) {
70118       {
70119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70120       };
70121     } catch (...) {
70122       {
70123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70124       };
70125     }
70126   }
70127
70128   jresult = result;
70129   return jresult;
70130 }
70131
70132
70133 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetInitialAutoRepeatingDelay(void * jarg1) {
70134   float jresult ;
70135   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70136   float result;
70137
70138   arg1 = (Dali::Toolkit::Button *)jarg1;
70139   {
70140     try {
70141       result = (float)((Dali::Toolkit::Button const *)arg1)->GetInitialAutoRepeatingDelay();
70142     } catch (std::out_of_range& e) {
70143       {
70144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70145       };
70146     } catch (std::exception& e) {
70147       {
70148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70149       };
70150     } catch (Dali::DaliException e) {
70151       {
70152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70153       };
70154     } catch (...) {
70155       {
70156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70157       };
70158     }
70159   }
70160
70161   jresult = result;
70162   return jresult;
70163 }
70164
70165
70166 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetNextAutoRepeatingDelay(void * jarg1) {
70167   float jresult ;
70168   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70169   float result;
70170
70171   arg1 = (Dali::Toolkit::Button *)jarg1;
70172   {
70173     try {
70174       result = (float)((Dali::Toolkit::Button const *)arg1)->GetNextAutoRepeatingDelay();
70175     } catch (std::out_of_range& e) {
70176       {
70177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70178       };
70179     } catch (std::exception& e) {
70180       {
70181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70182       };
70183     } catch (Dali::DaliException e) {
70184       {
70185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70186       };
70187     } catch (...) {
70188       {
70189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70190       };
70191     }
70192   }
70193
70194   jresult = result;
70195   return jresult;
70196 }
70197
70198
70199 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsTogglableButton(void * jarg1) {
70200   unsigned int jresult ;
70201   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70202   bool result;
70203
70204   arg1 = (Dali::Toolkit::Button *)jarg1;
70205   {
70206     try {
70207       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsTogglableButton();
70208     } catch (std::out_of_range& e) {
70209       {
70210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70211       };
70212     } catch (std::exception& e) {
70213       {
70214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70215       };
70216     } catch (Dali::DaliException e) {
70217       {
70218         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70219       };
70220     } catch (...) {
70221       {
70222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70223       };
70224     }
70225   }
70226
70227   jresult = result;
70228   return jresult;
70229 }
70230
70231
70232 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsSelected(void * jarg1) {
70233   unsigned int jresult ;
70234   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70235   bool result;
70236
70237   arg1 = (Dali::Toolkit::Button *)jarg1;
70238   {
70239     try {
70240       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsSelected();
70241     } catch (std::out_of_range& e) {
70242       {
70243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70244       };
70245     } catch (std::exception& e) {
70246       {
70247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70248       };
70249     } catch (Dali::DaliException e) {
70250       {
70251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70252       };
70253     } catch (...) {
70254       {
70255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70256       };
70257     }
70258   }
70259
70260   jresult = result;
70261   return jresult;
70262 }
70263
70264
70265 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetAnimationTime(void * jarg1) {
70266   float jresult ;
70267   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70268   float result;
70269
70270   arg1 = (Dali::Toolkit::Button *)jarg1;
70271   {
70272     try {
70273       result = (float)((Dali::Toolkit::Button const *)arg1)->GetAnimationTime();
70274     } catch (std::out_of_range& e) {
70275       {
70276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70277       };
70278     } catch (std::exception& e) {
70279       {
70280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70281       };
70282     } catch (Dali::DaliException e) {
70283       {
70284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70285       };
70286     } catch (...) {
70287       {
70288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70289       };
70290     }
70291   }
70292
70293   jresult = result;
70294   return jresult;
70295 }
70296
70297
70298 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Button_GetLabelText(void * jarg1) {
70299   char * jresult ;
70300   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70301   std::string result;
70302
70303   arg1 = (Dali::Toolkit::Button *)jarg1;
70304   {
70305     try {
70306       result = ((Dali::Toolkit::Button const *)arg1)->GetLabelText();
70307     } catch (std::out_of_range& e) {
70308       {
70309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70310       };
70311     } catch (std::exception& e) {
70312       {
70313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70314       };
70315     } catch (Dali::DaliException e) {
70316       {
70317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70318       };
70319     } catch (...) {
70320       {
70321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70322       };
70323     }
70324   }
70325
70326   jresult = SWIG_csharp_string_callback((&result)->c_str());
70327   return jresult;
70328 }
70329
70330
70331 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetLabel(void * jarg1, void * jarg2) {
70332   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70333   Dali::Actor arg2 ;
70334   Dali::Actor *argp2 ;
70335
70336   arg1 = (Dali::Toolkit::Button *)jarg1;
70337   argp2 = (Dali::Actor *)jarg2;
70338   if (!argp2) {
70339     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70340     return ;
70341   }
70342   arg2 = *argp2;
70343   {
70344     try {
70345       (arg1)->SetLabel(arg2);
70346     } catch (std::out_of_range& e) {
70347       {
70348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70349       };
70350     } catch (std::exception& e) {
70351       {
70352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70353       };
70354     } catch (Dali::DaliException e) {
70355       {
70356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70357       };
70358     } catch (...) {
70359       {
70360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70361       };
70362     }
70363   }
70364
70365 }
70366
70367
70368 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetButtonImage(void * jarg1, void * jarg2) {
70369   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70370   Dali::Image arg2 ;
70371   Dali::Image *argp2 ;
70372
70373   arg1 = (Dali::Toolkit::Button *)jarg1;
70374   argp2 = (Dali::Image *)jarg2;
70375   if (!argp2) {
70376     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
70377     return ;
70378   }
70379   arg2 = *argp2;
70380   {
70381     try {
70382       (arg1)->SetButtonImage(arg2);
70383     } catch (std::out_of_range& e) {
70384       {
70385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70386       };
70387     } catch (std::exception& e) {
70388       {
70389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70390       };
70391     } catch (Dali::DaliException e) {
70392       {
70393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70394       };
70395     } catch (...) {
70396       {
70397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70398       };
70399     }
70400   }
70401
70402 }
70403
70404
70405 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetSelectedImage(void * jarg1, void * jarg2) {
70406   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70407   Dali::Image arg2 ;
70408   Dali::Image *argp2 ;
70409
70410   arg1 = (Dali::Toolkit::Button *)jarg1;
70411   argp2 = (Dali::Image *)jarg2;
70412   if (!argp2) {
70413     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
70414     return ;
70415   }
70416   arg2 = *argp2;
70417   {
70418     try {
70419       (arg1)->SetSelectedImage(arg2);
70420     } catch (std::out_of_range& e) {
70421       {
70422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70423       };
70424     } catch (std::exception& e) {
70425       {
70426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70427       };
70428     } catch (Dali::DaliException e) {
70429       {
70430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70431       };
70432     } catch (...) {
70433       {
70434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70435       };
70436     }
70437   }
70438
70439 }
70440
70441
70442 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetButtonImage(void * jarg1) {
70443   void * jresult ;
70444   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70445   Dali::Actor result;
70446
70447   arg1 = (Dali::Toolkit::Button *)jarg1;
70448   {
70449     try {
70450       result = ((Dali::Toolkit::Button const *)arg1)->GetButtonImage();
70451     } catch (std::out_of_range& e) {
70452       {
70453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70454       };
70455     } catch (std::exception& e) {
70456       {
70457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70458       };
70459     } catch (Dali::DaliException e) {
70460       {
70461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70462       };
70463     } catch (...) {
70464       {
70465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70466       };
70467     }
70468   }
70469
70470   jresult = new Dali::Actor((const Dali::Actor &)result);
70471   return jresult;
70472 }
70473
70474
70475 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetSelectedImage(void * jarg1) {
70476   void * jresult ;
70477   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70478   Dali::Actor result;
70479
70480   arg1 = (Dali::Toolkit::Button *)jarg1;
70481   {
70482     try {
70483       result = ((Dali::Toolkit::Button const *)arg1)->GetSelectedImage();
70484     } catch (std::out_of_range& e) {
70485       {
70486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70487       };
70488     } catch (std::exception& e) {
70489       {
70490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70491       };
70492     } catch (Dali::DaliException e) {
70493       {
70494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70495       };
70496     } catch (...) {
70497       {
70498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70499       };
70500     }
70501   }
70502
70503   jresult = new Dali::Actor((const Dali::Actor &)result);
70504   return jresult;
70505 }
70506
70507
70508 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_PressedSignal(void * jarg1) {
70509   void * jresult ;
70510   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70511   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
70512
70513   arg1 = (Dali::Toolkit::Button *)jarg1;
70514   {
70515     try {
70516       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->PressedSignal();
70517     } catch (std::out_of_range& e) {
70518       {
70519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70520       };
70521     } catch (std::exception& e) {
70522       {
70523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70524       };
70525     } catch (Dali::DaliException e) {
70526       {
70527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70528       };
70529     } catch (...) {
70530       {
70531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70532       };
70533     }
70534   }
70535
70536   jresult = (void *)result;
70537   return jresult;
70538 }
70539
70540
70541 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ReleasedSignal(void * jarg1) {
70542   void * jresult ;
70543   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70544   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
70545
70546   arg1 = (Dali::Toolkit::Button *)jarg1;
70547   {
70548     try {
70549       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ReleasedSignal();
70550     } catch (std::out_of_range& e) {
70551       {
70552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70553       };
70554     } catch (std::exception& e) {
70555       {
70556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70557       };
70558     } catch (Dali::DaliException e) {
70559       {
70560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70561       };
70562     } catch (...) {
70563       {
70564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70565       };
70566     }
70567   }
70568
70569   jresult = (void *)result;
70570   return jresult;
70571 }
70572
70573
70574 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ClickedSignal(void * jarg1) {
70575   void * jresult ;
70576   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70577   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
70578
70579   arg1 = (Dali::Toolkit::Button *)jarg1;
70580   {
70581     try {
70582       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ClickedSignal();
70583     } catch (std::out_of_range& e) {
70584       {
70585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70586       };
70587     } catch (std::exception& e) {
70588       {
70589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70590       };
70591     } catch (Dali::DaliException e) {
70592       {
70593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70594       };
70595     } catch (...) {
70596       {
70597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70598       };
70599     }
70600   }
70601
70602   jresult = (void *)result;
70603   return jresult;
70604 }
70605
70606
70607 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_StateChangedSignal(void * jarg1) {
70608   void * jresult ;
70609   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70610   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
70611
70612   arg1 = (Dali::Toolkit::Button *)jarg1;
70613   {
70614     try {
70615       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->StateChangedSignal();
70616     } catch (std::out_of_range& e) {
70617       {
70618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70619       };
70620     } catch (std::exception& e) {
70621       {
70622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70623       };
70624     } catch (Dali::DaliException e) {
70625       {
70626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70627       };
70628     } catch (...) {
70629       {
70630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70631       };
70632     }
70633   }
70634
70635   jresult = (void *)result;
70636   return jresult;
70637 }
70638
70639
70640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_0() {
70641   void * jresult ;
70642   Dali::Toolkit::CheckBoxButton *result = 0 ;
70643
70644   {
70645     try {
70646       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton();
70647     } catch (std::out_of_range& e) {
70648       {
70649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70650       };
70651     } catch (std::exception& e) {
70652       {
70653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70654       };
70655     } catch (Dali::DaliException e) {
70656       {
70657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70658       };
70659     } catch (...) {
70660       {
70661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70662       };
70663     }
70664   }
70665
70666   jresult = (void *)result;
70667   return jresult;
70668 }
70669
70670
70671 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_1(void * jarg1) {
70672   void * jresult ;
70673   Dali::Toolkit::CheckBoxButton *arg1 = 0 ;
70674   Dali::Toolkit::CheckBoxButton *result = 0 ;
70675
70676   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
70677   if (!arg1) {
70678     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
70679     return 0;
70680   }
70681   {
70682     try {
70683       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton((Dali::Toolkit::CheckBoxButton const &)*arg1);
70684     } catch (std::out_of_range& e) {
70685       {
70686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70687       };
70688     } catch (std::exception& e) {
70689       {
70690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70691       };
70692     } catch (Dali::DaliException e) {
70693       {
70694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70695       };
70696     } catch (...) {
70697       {
70698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70699       };
70700     }
70701   }
70702
70703   jresult = (void *)result;
70704   return jresult;
70705 }
70706
70707
70708 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_Assign(void * jarg1, void * jarg2) {
70709   void * jresult ;
70710   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
70711   Dali::Toolkit::CheckBoxButton *arg2 = 0 ;
70712   Dali::Toolkit::CheckBoxButton *result = 0 ;
70713
70714   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
70715   arg2 = (Dali::Toolkit::CheckBoxButton *)jarg2;
70716   if (!arg2) {
70717     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
70718     return 0;
70719   }
70720   {
70721     try {
70722       result = (Dali::Toolkit::CheckBoxButton *) &(arg1)->operator =((Dali::Toolkit::CheckBoxButton const &)*arg2);
70723     } catch (std::out_of_range& e) {
70724       {
70725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70726       };
70727     } catch (std::exception& e) {
70728       {
70729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70730       };
70731     } catch (Dali::DaliException e) {
70732       {
70733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70734       };
70735     } catch (...) {
70736       {
70737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70738       };
70739     }
70740   }
70741
70742   jresult = (void *)result;
70743   return jresult;
70744 }
70745
70746
70747 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CheckBoxButton(void * jarg1) {
70748   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
70749
70750   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
70751   {
70752     try {
70753       delete arg1;
70754     } catch (std::out_of_range& e) {
70755       {
70756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70757       };
70758     } catch (std::exception& e) {
70759       {
70760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70761       };
70762     } catch (Dali::DaliException e) {
70763       {
70764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70765       };
70766     } catch (...) {
70767       {
70768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70769       };
70770     }
70771   }
70772
70773 }
70774
70775
70776 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_New() {
70777   void * jresult ;
70778   Dali::Toolkit::CheckBoxButton result;
70779
70780   {
70781     try {
70782       result = Dali::Toolkit::CheckBoxButton::New();
70783     } catch (std::out_of_range& e) {
70784       {
70785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70786       };
70787     } catch (std::exception& e) {
70788       {
70789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70790       };
70791     } catch (Dali::DaliException e) {
70792       {
70793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70794       };
70795     } catch (...) {
70796       {
70797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70798       };
70799     }
70800   }
70801
70802   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
70803   return jresult;
70804 }
70805
70806
70807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_DownCast(void * jarg1) {
70808   void * jresult ;
70809   Dali::BaseHandle arg1 ;
70810   Dali::BaseHandle *argp1 ;
70811   Dali::Toolkit::CheckBoxButton result;
70812
70813   argp1 = (Dali::BaseHandle *)jarg1;
70814   if (!argp1) {
70815     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
70816     return 0;
70817   }
70818   arg1 = *argp1;
70819   {
70820     try {
70821       result = Dali::Toolkit::CheckBoxButton::DownCast(arg1);
70822     } catch (std::out_of_range& e) {
70823       {
70824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70825       };
70826     } catch (std::exception& e) {
70827       {
70828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70829       };
70830     } catch (Dali::DaliException e) {
70831       {
70832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70833       };
70834     } catch (...) {
70835       {
70836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70837       };
70838     }
70839   }
70840
70841   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
70842   return jresult;
70843 }
70844
70845
70846 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_UNSELECTED_ICON_get() {
70847   int jresult ;
70848   int result;
70849
70850   result = (int)Dali::Toolkit::PushButton::Property::UNSELECTED_ICON;
70851   jresult = (int)result;
70852   return jresult;
70853 }
70854
70855
70856 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_SELECTED_ICON_get() {
70857   int jresult ;
70858   int result;
70859
70860   result = (int)Dali::Toolkit::PushButton::Property::SELECTED_ICON;
70861   jresult = (int)result;
70862   return jresult;
70863 }
70864
70865
70866 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_ALIGNMENT_get() {
70867   int jresult ;
70868   int result;
70869
70870   result = (int)Dali::Toolkit::PushButton::Property::ICON_ALIGNMENT;
70871   jresult = (int)result;
70872   return jresult;
70873 }
70874
70875
70876 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_LABEL_PADDING_get() {
70877   int jresult ;
70878   int result;
70879
70880   result = (int)Dali::Toolkit::PushButton::Property::LABEL_PADDING;
70881   jresult = (int)result;
70882   return jresult;
70883 }
70884
70885
70886 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_PADDING_get() {
70887   int jresult ;
70888   int result;
70889
70890   result = (int)Dali::Toolkit::PushButton::Property::ICON_PADDING;
70891   jresult = (int)result;
70892   return jresult;
70893 }
70894
70895
70896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton_Property() {
70897   void * jresult ;
70898   Dali::Toolkit::PushButton::Property *result = 0 ;
70899
70900   {
70901     try {
70902       result = (Dali::Toolkit::PushButton::Property *)new Dali::Toolkit::PushButton::Property();
70903     } catch (std::out_of_range& e) {
70904       {
70905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70906       };
70907     } catch (std::exception& e) {
70908       {
70909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70910       };
70911     } catch (Dali::DaliException e) {
70912       {
70913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70914       };
70915     } catch (...) {
70916       {
70917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70918       };
70919     }
70920   }
70921
70922   jresult = (void *)result;
70923   return jresult;
70924 }
70925
70926
70927 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton_Property(void * jarg1) {
70928   Dali::Toolkit::PushButton::Property *arg1 = (Dali::Toolkit::PushButton::Property *) 0 ;
70929
70930   arg1 = (Dali::Toolkit::PushButton::Property *)jarg1;
70931   {
70932     try {
70933       delete arg1;
70934     } catch (std::out_of_range& e) {
70935       {
70936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70937       };
70938     } catch (std::exception& e) {
70939       {
70940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70941       };
70942     } catch (Dali::DaliException e) {
70943       {
70944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70945       };
70946     } catch (...) {
70947       {
70948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70949       };
70950     }
70951   }
70952
70953 }
70954
70955
70956 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_0() {
70957   void * jresult ;
70958   Dali::Toolkit::PushButton *result = 0 ;
70959
70960   {
70961     try {
70962       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton();
70963     } catch (std::out_of_range& e) {
70964       {
70965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70966       };
70967     } catch (std::exception& e) {
70968       {
70969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70970       };
70971     } catch (Dali::DaliException e) {
70972       {
70973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70974       };
70975     } catch (...) {
70976       {
70977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70978       };
70979     }
70980   }
70981
70982   jresult = (void *)result;
70983   return jresult;
70984 }
70985
70986
70987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_1(void * jarg1) {
70988   void * jresult ;
70989   Dali::Toolkit::PushButton *arg1 = 0 ;
70990   Dali::Toolkit::PushButton *result = 0 ;
70991
70992   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70993   if (!arg1) {
70994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
70995     return 0;
70996   }
70997   {
70998     try {
70999       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton((Dali::Toolkit::PushButton const &)*arg1);
71000     } catch (std::out_of_range& e) {
71001       {
71002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71003       };
71004     } catch (std::exception& e) {
71005       {
71006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71007       };
71008     } catch (Dali::DaliException e) {
71009       {
71010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71011       };
71012     } catch (...) {
71013       {
71014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71015       };
71016     }
71017   }
71018
71019   jresult = (void *)result;
71020   return jresult;
71021 }
71022
71023
71024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_Assign(void * jarg1, void * jarg2) {
71025   void * jresult ;
71026   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71027   Dali::Toolkit::PushButton *arg2 = 0 ;
71028   Dali::Toolkit::PushButton *result = 0 ;
71029
71030   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71031   arg2 = (Dali::Toolkit::PushButton *)jarg2;
71032   if (!arg2) {
71033     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
71034     return 0;
71035   }
71036   {
71037     try {
71038       result = (Dali::Toolkit::PushButton *) &(arg1)->operator =((Dali::Toolkit::PushButton const &)*arg2);
71039     } catch (std::out_of_range& e) {
71040       {
71041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71042       };
71043     } catch (std::exception& e) {
71044       {
71045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71046       };
71047     } catch (Dali::DaliException e) {
71048       {
71049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71050       };
71051     } catch (...) {
71052       {
71053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71054       };
71055     }
71056   }
71057
71058   jresult = (void *)result;
71059   return jresult;
71060 }
71061
71062
71063 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton(void * jarg1) {
71064   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71065
71066   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71067   {
71068     try {
71069       delete arg1;
71070     } catch (std::out_of_range& e) {
71071       {
71072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71073       };
71074     } catch (std::exception& e) {
71075       {
71076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71077       };
71078     } catch (Dali::DaliException e) {
71079       {
71080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71081       };
71082     } catch (...) {
71083       {
71084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71085       };
71086     }
71087   }
71088
71089 }
71090
71091
71092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_New() {
71093   void * jresult ;
71094   Dali::Toolkit::PushButton result;
71095
71096   {
71097     try {
71098       result = Dali::Toolkit::PushButton::New();
71099     } catch (std::out_of_range& e) {
71100       {
71101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71102       };
71103     } catch (std::exception& e) {
71104       {
71105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71106       };
71107     } catch (Dali::DaliException e) {
71108       {
71109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71110       };
71111     } catch (...) {
71112       {
71113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71114       };
71115     }
71116   }
71117
71118   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
71119   return jresult;
71120 }
71121
71122
71123 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_DownCast(void * jarg1) {
71124   void * jresult ;
71125   Dali::BaseHandle arg1 ;
71126   Dali::BaseHandle *argp1 ;
71127   Dali::Toolkit::PushButton result;
71128
71129   argp1 = (Dali::BaseHandle *)jarg1;
71130   if (!argp1) {
71131     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
71132     return 0;
71133   }
71134   arg1 = *argp1;
71135   {
71136     try {
71137       result = Dali::Toolkit::PushButton::DownCast(arg1);
71138     } catch (std::out_of_range& e) {
71139       {
71140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71141       };
71142     } catch (std::exception& e) {
71143       {
71144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71145       };
71146     } catch (Dali::DaliException e) {
71147       {
71148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71149       };
71150     } catch (...) {
71151       {
71152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71153       };
71154     }
71155   }
71156
71157   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
71158   return jresult;
71159 }
71160
71161
71162 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_0_0(void * jarg1, void * jarg2) {
71163   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71164   Dali::Image arg2 ;
71165   Dali::Image *argp2 ;
71166
71167   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71168   argp2 = (Dali::Image *)jarg2;
71169   if (!argp2) {
71170     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
71171     return ;
71172   }
71173   arg2 = *argp2;
71174   {
71175     try {
71176       (arg1)->SetButtonImage(arg2);
71177     } catch (std::out_of_range& e) {
71178       {
71179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71180       };
71181     } catch (std::exception& e) {
71182       {
71183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71184       };
71185     } catch (Dali::DaliException e) {
71186       {
71187         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71188       };
71189     } catch (...) {
71190       {
71191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71192       };
71193     }
71194   }
71195
71196 }
71197
71198
71199 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_1(void * jarg1, void * jarg2) {
71200   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71201   Dali::Actor arg2 ;
71202   Dali::Actor *argp2 ;
71203
71204   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71205   argp2 = (Dali::Actor *)jarg2;
71206   if (!argp2) {
71207     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71208     return ;
71209   }
71210   arg2 = *argp2;
71211   {
71212     try {
71213       (arg1)->SetButtonImage(arg2);
71214     } catch (std::out_of_range& e) {
71215       {
71216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71217       };
71218     } catch (std::exception& e) {
71219       {
71220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71221       };
71222     } catch (Dali::DaliException e) {
71223       {
71224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71225       };
71226     } catch (...) {
71227       {
71228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71229       };
71230     }
71231   }
71232
71233 }
71234
71235
71236 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetBackgroundImage(void * jarg1, void * jarg2) {
71237   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71238   Dali::Actor arg2 ;
71239   Dali::Actor *argp2 ;
71240
71241   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71242   argp2 = (Dali::Actor *)jarg2;
71243   if (!argp2) {
71244     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71245     return ;
71246   }
71247   arg2 = *argp2;
71248   {
71249     try {
71250       (arg1)->SetBackgroundImage(arg2);
71251     } catch (std::out_of_range& e) {
71252       {
71253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71254       };
71255     } catch (std::exception& e) {
71256       {
71257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71258       };
71259     } catch (Dali::DaliException e) {
71260       {
71261         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71262       };
71263     } catch (...) {
71264       {
71265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71266       };
71267     }
71268   }
71269
71270 }
71271
71272
71273 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_0_0(void * jarg1, void * jarg2) {
71274   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71275   Dali::Image arg2 ;
71276   Dali::Image *argp2 ;
71277
71278   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71279   argp2 = (Dali::Image *)jarg2;
71280   if (!argp2) {
71281     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
71282     return ;
71283   }
71284   arg2 = *argp2;
71285   {
71286     try {
71287       (arg1)->SetSelectedImage(arg2);
71288     } catch (std::out_of_range& e) {
71289       {
71290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71291       };
71292     } catch (std::exception& e) {
71293       {
71294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71295       };
71296     } catch (Dali::DaliException e) {
71297       {
71298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71299       };
71300     } catch (...) {
71301       {
71302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71303       };
71304     }
71305   }
71306
71307 }
71308
71309
71310 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_1(void * jarg1, void * jarg2) {
71311   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71312   Dali::Actor arg2 ;
71313   Dali::Actor *argp2 ;
71314
71315   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71316   argp2 = (Dali::Actor *)jarg2;
71317   if (!argp2) {
71318     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71319     return ;
71320   }
71321   arg2 = *argp2;
71322   {
71323     try {
71324       (arg1)->SetSelectedImage(arg2);
71325     } catch (std::out_of_range& e) {
71326       {
71327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71328       };
71329     } catch (std::exception& e) {
71330       {
71331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71332       };
71333     } catch (Dali::DaliException e) {
71334       {
71335         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71336       };
71337     } catch (...) {
71338       {
71339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71340       };
71341     }
71342   }
71343
71344 }
71345
71346
71347 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedBackgroundImage(void * jarg1, void * jarg2) {
71348   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71349   Dali::Actor arg2 ;
71350   Dali::Actor *argp2 ;
71351
71352   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71353   argp2 = (Dali::Actor *)jarg2;
71354   if (!argp2) {
71355     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71356     return ;
71357   }
71358   arg2 = *argp2;
71359   {
71360     try {
71361       (arg1)->SetSelectedBackgroundImage(arg2);
71362     } catch (std::out_of_range& e) {
71363       {
71364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71365       };
71366     } catch (std::exception& e) {
71367       {
71368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71369       };
71370     } catch (Dali::DaliException e) {
71371       {
71372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71373       };
71374     } catch (...) {
71375       {
71376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71377       };
71378     }
71379   }
71380
71381 }
71382
71383
71384 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledBackgroundImage(void * jarg1, void * jarg2) {
71385   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71386   Dali::Actor arg2 ;
71387   Dali::Actor *argp2 ;
71388
71389   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71390   argp2 = (Dali::Actor *)jarg2;
71391   if (!argp2) {
71392     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71393     return ;
71394   }
71395   arg2 = *argp2;
71396   {
71397     try {
71398       (arg1)->SetDisabledBackgroundImage(arg2);
71399     } catch (std::out_of_range& e) {
71400       {
71401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71402       };
71403     } catch (std::exception& e) {
71404       {
71405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71406       };
71407     } catch (Dali::DaliException e) {
71408       {
71409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71410       };
71411     } catch (...) {
71412       {
71413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71414       };
71415     }
71416   }
71417
71418 }
71419
71420
71421 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledImage(void * jarg1, void * jarg2) {
71422   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71423   Dali::Actor arg2 ;
71424   Dali::Actor *argp2 ;
71425
71426   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71427   argp2 = (Dali::Actor *)jarg2;
71428   if (!argp2) {
71429     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71430     return ;
71431   }
71432   arg2 = *argp2;
71433   {
71434     try {
71435       (arg1)->SetDisabledImage(arg2);
71436     } catch (std::out_of_range& e) {
71437       {
71438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71439       };
71440     } catch (std::exception& e) {
71441       {
71442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71443       };
71444     } catch (Dali::DaliException e) {
71445       {
71446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71447       };
71448     } catch (...) {
71449       {
71450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71451       };
71452     }
71453   }
71454
71455 }
71456
71457
71458 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledSelectedImage(void * jarg1, void * jarg2) {
71459   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71460   Dali::Actor arg2 ;
71461   Dali::Actor *argp2 ;
71462
71463   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71464   argp2 = (Dali::Actor *)jarg2;
71465   if (!argp2) {
71466     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71467     return ;
71468   }
71469   arg2 = *argp2;
71470   {
71471     try {
71472       (arg1)->SetDisabledSelectedImage(arg2);
71473     } catch (std::out_of_range& e) {
71474       {
71475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71476       };
71477     } catch (std::exception& e) {
71478       {
71479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71480       };
71481     } catch (Dali::DaliException e) {
71482       {
71483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71484       };
71485     } catch (...) {
71486       {
71487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71488       };
71489     }
71490   }
71491
71492 }
71493
71494
71495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_0() {
71496   void * jresult ;
71497   Dali::Toolkit::RadioButton *result = 0 ;
71498
71499   {
71500     try {
71501       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton();
71502     } catch (std::out_of_range& e) {
71503       {
71504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71505       };
71506     } catch (std::exception& e) {
71507       {
71508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71509       };
71510     } catch (Dali::DaliException e) {
71511       {
71512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71513       };
71514     } catch (...) {
71515       {
71516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71517       };
71518     }
71519   }
71520
71521   jresult = (void *)result;
71522   return jresult;
71523 }
71524
71525
71526 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_1(void * jarg1) {
71527   void * jresult ;
71528   Dali::Toolkit::RadioButton *arg1 = 0 ;
71529   Dali::Toolkit::RadioButton *result = 0 ;
71530
71531   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
71532   if (!arg1) {
71533     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
71534     return 0;
71535   }
71536   {
71537     try {
71538       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton((Dali::Toolkit::RadioButton const &)*arg1);
71539     } catch (std::out_of_range& e) {
71540       {
71541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71542       };
71543     } catch (std::exception& e) {
71544       {
71545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71546       };
71547     } catch (Dali::DaliException e) {
71548       {
71549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71550       };
71551     } catch (...) {
71552       {
71553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71554       };
71555     }
71556   }
71557
71558   jresult = (void *)result;
71559   return jresult;
71560 }
71561
71562
71563 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_Assign(void * jarg1, void * jarg2) {
71564   void * jresult ;
71565   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
71566   Dali::Toolkit::RadioButton *arg2 = 0 ;
71567   Dali::Toolkit::RadioButton *result = 0 ;
71568
71569   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
71570   arg2 = (Dali::Toolkit::RadioButton *)jarg2;
71571   if (!arg2) {
71572     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
71573     return 0;
71574   }
71575   {
71576     try {
71577       result = (Dali::Toolkit::RadioButton *) &(arg1)->operator =((Dali::Toolkit::RadioButton const &)*arg2);
71578     } catch (std::out_of_range& e) {
71579       {
71580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71581       };
71582     } catch (std::exception& e) {
71583       {
71584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71585       };
71586     } catch (Dali::DaliException e) {
71587       {
71588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71589       };
71590     } catch (...) {
71591       {
71592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71593       };
71594     }
71595   }
71596
71597   jresult = (void *)result;
71598   return jresult;
71599 }
71600
71601
71602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RadioButton(void * jarg1) {
71603   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
71604
71605   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
71606   {
71607     try {
71608       delete arg1;
71609     } catch (std::out_of_range& e) {
71610       {
71611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71612       };
71613     } catch (std::exception& e) {
71614       {
71615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71616       };
71617     } catch (Dali::DaliException e) {
71618       {
71619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71620       };
71621     } catch (...) {
71622       {
71623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71624       };
71625     }
71626   }
71627
71628 }
71629
71630
71631 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_0() {
71632   void * jresult ;
71633   Dali::Toolkit::RadioButton result;
71634
71635   {
71636     try {
71637       result = Dali::Toolkit::RadioButton::New();
71638     } catch (std::out_of_range& e) {
71639       {
71640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71641       };
71642     } catch (std::exception& e) {
71643       {
71644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71645       };
71646     } catch (Dali::DaliException e) {
71647       {
71648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71649       };
71650     } catch (...) {
71651       {
71652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71653       };
71654     }
71655   }
71656
71657   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
71658   return jresult;
71659 }
71660
71661
71662 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_1(char * jarg1) {
71663   void * jresult ;
71664   std::string *arg1 = 0 ;
71665   Dali::Toolkit::RadioButton result;
71666
71667   if (!jarg1) {
71668     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
71669     return 0;
71670   }
71671   std::string arg1_str(jarg1);
71672   arg1 = &arg1_str;
71673   {
71674     try {
71675       result = Dali::Toolkit::RadioButton::New((std::string const &)*arg1);
71676     } catch (std::out_of_range& e) {
71677       {
71678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71679       };
71680     } catch (std::exception& e) {
71681       {
71682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71683       };
71684     } catch (Dali::DaliException e) {
71685       {
71686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71687       };
71688     } catch (...) {
71689       {
71690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71691       };
71692     }
71693   }
71694
71695   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
71696
71697   //argout typemap for const std::string&
71698
71699   return jresult;
71700 }
71701
71702
71703 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_DownCast(void * jarg1) {
71704   void * jresult ;
71705   Dali::BaseHandle arg1 ;
71706   Dali::BaseHandle *argp1 ;
71707   Dali::Toolkit::RadioButton result;
71708
71709   argp1 = (Dali::BaseHandle *)jarg1;
71710   if (!argp1) {
71711     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
71712     return 0;
71713   }
71714   arg1 = *argp1;
71715   {
71716     try {
71717       result = Dali::Toolkit::RadioButton::DownCast(arg1);
71718     } catch (std::out_of_range& e) {
71719       {
71720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71721       };
71722     } catch (std::exception& e) {
71723       {
71724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71725       };
71726     } catch (Dali::DaliException e) {
71727       {
71728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71729       };
71730     } catch (...) {
71731       {
71732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71733       };
71734     }
71735   }
71736
71737   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
71738   return jresult;
71739 }
71740
71741
71742 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_CONTENT_DIRECTION_get() {
71743   int jresult ;
71744   int result;
71745
71746   result = (int)Dali::Toolkit::FlexContainer::Property::CONTENT_DIRECTION;
71747   jresult = (int)result;
71748   return jresult;
71749 }
71750
71751
71752 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_DIRECTION_get() {
71753   int jresult ;
71754   int result;
71755
71756   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_DIRECTION;
71757   jresult = (int)result;
71758   return jresult;
71759 }
71760
71761
71762 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_WRAP_get() {
71763   int jresult ;
71764   int result;
71765
71766   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_WRAP;
71767   jresult = (int)result;
71768   return jresult;
71769 }
71770
71771
71772 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_JUSTIFY_CONTENT_get() {
71773   int jresult ;
71774   int result;
71775
71776   result = (int)Dali::Toolkit::FlexContainer::Property::JUSTIFY_CONTENT;
71777   jresult = (int)result;
71778   return jresult;
71779 }
71780
71781
71782 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_ITEMS_get() {
71783   int jresult ;
71784   int result;
71785
71786   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_ITEMS;
71787   jresult = (int)result;
71788   return jresult;
71789 }
71790
71791
71792 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_CONTENT_get() {
71793   int jresult ;
71794   int result;
71795
71796   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_CONTENT;
71797   jresult = (int)result;
71798   return jresult;
71799 }
71800
71801
71802 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_Property() {
71803   void * jresult ;
71804   Dali::Toolkit::FlexContainer::Property *result = 0 ;
71805
71806   {
71807     try {
71808       result = (Dali::Toolkit::FlexContainer::Property *)new Dali::Toolkit::FlexContainer::Property();
71809     } catch (std::out_of_range& e) {
71810       {
71811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71812       };
71813     } catch (std::exception& e) {
71814       {
71815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71816       };
71817     } catch (Dali::DaliException e) {
71818       {
71819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71820       };
71821     } catch (...) {
71822       {
71823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71824       };
71825     }
71826   }
71827
71828   jresult = (void *)result;
71829   return jresult;
71830 }
71831
71832
71833 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_Property(void * jarg1) {
71834   Dali::Toolkit::FlexContainer::Property *arg1 = (Dali::Toolkit::FlexContainer::Property *) 0 ;
71835
71836   arg1 = (Dali::Toolkit::FlexContainer::Property *)jarg1;
71837   {
71838     try {
71839       delete arg1;
71840     } catch (std::out_of_range& e) {
71841       {
71842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71843       };
71844     } catch (std::exception& e) {
71845       {
71846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71847       };
71848     } catch (Dali::DaliException e) {
71849       {
71850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71851       };
71852     } catch (...) {
71853       {
71854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71855       };
71856     }
71857   }
71858
71859 }
71860
71861
71862 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_get() {
71863   int jresult ;
71864   int result;
71865
71866   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX;
71867   jresult = (int)result;
71868   return jresult;
71869 }
71870
71871
71872 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_ALIGN_SELF_get() {
71873   int jresult ;
71874   int result;
71875
71876   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::ALIGN_SELF;
71877   jresult = (int)result;
71878   return jresult;
71879 }
71880
71881
71882 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_MARGIN_get() {
71883   int jresult ;
71884   int result;
71885
71886   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX_MARGIN;
71887   jresult = (int)result;
71888   return jresult;
71889 }
71890
71891
71892 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_ChildProperty() {
71893   void * jresult ;
71894   Dali::Toolkit::FlexContainer::ChildProperty *result = 0 ;
71895
71896   {
71897     try {
71898       result = (Dali::Toolkit::FlexContainer::ChildProperty *)new Dali::Toolkit::FlexContainer::ChildProperty();
71899     } catch (std::out_of_range& e) {
71900       {
71901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71902       };
71903     } catch (std::exception& e) {
71904       {
71905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71906       };
71907     } catch (Dali::DaliException e) {
71908       {
71909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71910       };
71911     } catch (...) {
71912       {
71913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71914       };
71915     }
71916   }
71917
71918   jresult = (void *)result;
71919   return jresult;
71920 }
71921
71922
71923 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_ChildProperty(void * jarg1) {
71924   Dali::Toolkit::FlexContainer::ChildProperty *arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *) 0 ;
71925
71926   arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *)jarg1;
71927   {
71928     try {
71929       delete arg1;
71930     } catch (std::out_of_range& e) {
71931       {
71932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71933       };
71934     } catch (std::exception& e) {
71935       {
71936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71937       };
71938     } catch (Dali::DaliException e) {
71939       {
71940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71941       };
71942     } catch (...) {
71943       {
71944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71945       };
71946     }
71947   }
71948
71949 }
71950
71951
71952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_0() {
71953   void * jresult ;
71954   Dali::Toolkit::FlexContainer *result = 0 ;
71955
71956   {
71957     try {
71958       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer();
71959     } catch (std::out_of_range& e) {
71960       {
71961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71962       };
71963     } catch (std::exception& e) {
71964       {
71965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71966       };
71967     } catch (Dali::DaliException e) {
71968       {
71969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71970       };
71971     } catch (...) {
71972       {
71973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71974       };
71975     }
71976   }
71977
71978   jresult = (void *)result;
71979   return jresult;
71980 }
71981
71982
71983 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_1(void * jarg1) {
71984   void * jresult ;
71985   Dali::Toolkit::FlexContainer *arg1 = 0 ;
71986   Dali::Toolkit::FlexContainer *result = 0 ;
71987
71988   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
71989   if (!arg1) {
71990     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
71991     return 0;
71992   }
71993   {
71994     try {
71995       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer((Dali::Toolkit::FlexContainer const &)*arg1);
71996     } catch (std::out_of_range& e) {
71997       {
71998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71999       };
72000     } catch (std::exception& e) {
72001       {
72002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72003       };
72004     } catch (Dali::DaliException e) {
72005       {
72006         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72007       };
72008     } catch (...) {
72009       {
72010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72011       };
72012     }
72013   }
72014
72015   jresult = (void *)result;
72016   return jresult;
72017 }
72018
72019
72020 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_Assign(void * jarg1, void * jarg2) {
72021   void * jresult ;
72022   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
72023   Dali::Toolkit::FlexContainer *arg2 = 0 ;
72024   Dali::Toolkit::FlexContainer *result = 0 ;
72025
72026   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
72027   arg2 = (Dali::Toolkit::FlexContainer *)jarg2;
72028   if (!arg2) {
72029     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
72030     return 0;
72031   }
72032   {
72033     try {
72034       result = (Dali::Toolkit::FlexContainer *) &(arg1)->operator =((Dali::Toolkit::FlexContainer const &)*arg2);
72035     } catch (std::out_of_range& e) {
72036       {
72037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72038       };
72039     } catch (std::exception& e) {
72040       {
72041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72042       };
72043     } catch (Dali::DaliException e) {
72044       {
72045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72046       };
72047     } catch (...) {
72048       {
72049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72050       };
72051     }
72052   }
72053
72054   jresult = (void *)result;
72055   return jresult;
72056 }
72057
72058
72059 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer(void * jarg1) {
72060   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
72061
72062   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
72063   {
72064     try {
72065       delete arg1;
72066     } catch (std::out_of_range& e) {
72067       {
72068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72069       };
72070     } catch (std::exception& e) {
72071       {
72072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72073       };
72074     } catch (Dali::DaliException e) {
72075       {
72076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72077       };
72078     } catch (...) {
72079       {
72080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72081       };
72082     }
72083   }
72084
72085 }
72086
72087
72088 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_New() {
72089   void * jresult ;
72090   Dali::Toolkit::FlexContainer result;
72091
72092   {
72093     try {
72094       result = Dali::Toolkit::FlexContainer::New();
72095     } catch (std::out_of_range& e) {
72096       {
72097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72098       };
72099     } catch (std::exception& e) {
72100       {
72101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72102       };
72103     } catch (Dali::DaliException e) {
72104       {
72105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72106       };
72107     } catch (...) {
72108       {
72109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72110       };
72111     }
72112   }
72113
72114   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
72115   return jresult;
72116 }
72117
72118
72119 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_DownCast(void * jarg1) {
72120   void * jresult ;
72121   Dali::BaseHandle arg1 ;
72122   Dali::BaseHandle *argp1 ;
72123   Dali::Toolkit::FlexContainer result;
72124
72125   argp1 = (Dali::BaseHandle *)jarg1;
72126   if (!argp1) {
72127     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
72128     return 0;
72129   }
72130   arg1 = *argp1;
72131   {
72132     try {
72133       result = Dali::Toolkit::FlexContainer::DownCast(arg1);
72134     } catch (std::out_of_range& e) {
72135       {
72136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72137       };
72138     } catch (std::exception& e) {
72139       {
72140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72141       };
72142     } catch (Dali::DaliException e) {
72143       {
72144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72145       };
72146     } catch (...) {
72147       {
72148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72149       };
72150     }
72151   }
72152
72153   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
72154   return jresult;
72155 }
72156
72157
72158 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_RESOURCE_URL_get() {
72159   int jresult ;
72160   int result;
72161
72162   result = (int)Dali::Toolkit::ImageView::Property::RESOURCE_URL;
72163   jresult = (int)result;
72164   return jresult;
72165 }
72166
72167
72168 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_IMAGE_get() {
72169   int jresult ;
72170   int result;
72171
72172   result = (int)Dali::Toolkit::ImageView::Property::IMAGE;
72173   jresult = (int)result;
72174   return jresult;
72175 }
72176
72177
72178 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PRE_MULTIPLIED_ALPHA_get() {
72179   int jresult ;
72180   int result;
72181
72182   result = (int)Dali::Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA;
72183   jresult = (int)result;
72184   return jresult;
72185 }
72186
72187
72188 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PIXEL_AREA_get() {
72189   int jresult ;
72190   int result;
72191
72192   result = (int)Dali::Toolkit::ImageView::Property::PIXEL_AREA;
72193   jresult = (int)result;
72194   return jresult;
72195 }
72196
72197
72198 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView_Property() {
72199   void * jresult ;
72200   Dali::Toolkit::ImageView::Property *result = 0 ;
72201
72202   {
72203     try {
72204       result = (Dali::Toolkit::ImageView::Property *)new Dali::Toolkit::ImageView::Property();
72205     } catch (std::out_of_range& e) {
72206       {
72207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72208       };
72209     } catch (std::exception& e) {
72210       {
72211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72212       };
72213     } catch (Dali::DaliException e) {
72214       {
72215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72216       };
72217     } catch (...) {
72218       {
72219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72220       };
72221     }
72222   }
72223
72224   jresult = (void *)result;
72225   return jresult;
72226 }
72227
72228
72229 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView_Property(void * jarg1) {
72230   Dali::Toolkit::ImageView::Property *arg1 = (Dali::Toolkit::ImageView::Property *) 0 ;
72231
72232   arg1 = (Dali::Toolkit::ImageView::Property *)jarg1;
72233   {
72234     try {
72235       delete arg1;
72236     } catch (std::out_of_range& e) {
72237       {
72238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72239       };
72240     } catch (std::exception& e) {
72241       {
72242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72243       };
72244     } catch (Dali::DaliException e) {
72245       {
72246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72247       };
72248     } catch (...) {
72249       {
72250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72251       };
72252     }
72253   }
72254
72255 }
72256
72257
72258 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_0() {
72259   void * jresult ;
72260   Dali::Toolkit::ImageView *result = 0 ;
72261
72262   {
72263     try {
72264       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView();
72265     } catch (std::out_of_range& e) {
72266       {
72267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72268       };
72269     } catch (std::exception& e) {
72270       {
72271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72272       };
72273     } catch (Dali::DaliException e) {
72274       {
72275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72276       };
72277     } catch (...) {
72278       {
72279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72280       };
72281     }
72282   }
72283
72284   jresult = (void *)result;
72285   return jresult;
72286 }
72287
72288
72289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_0() {
72290   void * jresult ;
72291   Dali::Toolkit::ImageView result;
72292
72293   {
72294     try {
72295       result = Dali::Toolkit::ImageView::New();
72296     } catch (std::out_of_range& e) {
72297       {
72298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72299       };
72300     } catch (std::exception& e) {
72301       {
72302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72303       };
72304     } catch (Dali::DaliException e) {
72305       {
72306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72307       };
72308     } catch (...) {
72309       {
72310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72311       };
72312     }
72313   }
72314
72315   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
72316   return jresult;
72317 }
72318
72319
72320 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_1(void * jarg1) {
72321   void * jresult ;
72322   Dali::Image arg1 ;
72323   Dali::Image *argp1 ;
72324   Dali::Toolkit::ImageView result;
72325
72326   argp1 = (Dali::Image *)jarg1;
72327   if (!argp1) {
72328     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
72329     return 0;
72330   }
72331   arg1 = *argp1;
72332   {
72333     try {
72334       result = Dali::Toolkit::ImageView::New(arg1);
72335     } catch (std::out_of_range& e) {
72336       {
72337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72338       };
72339     } catch (std::exception& e) {
72340       {
72341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72342       };
72343     } catch (Dali::DaliException e) {
72344       {
72345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72346       };
72347     } catch (...) {
72348       {
72349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72350       };
72351     }
72352   }
72353
72354   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
72355   return jresult;
72356 }
72357
72358
72359 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_2(char * jarg1) {
72360   void * jresult ;
72361   std::string *arg1 = 0 ;
72362   Dali::Toolkit::ImageView result;
72363
72364   if (!jarg1) {
72365     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72366     return 0;
72367   }
72368   std::string arg1_str(jarg1);
72369   arg1 = &arg1_str;
72370   {
72371     try {
72372       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1);
72373     } catch (std::out_of_range& e) {
72374       {
72375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72376       };
72377     } catch (std::exception& e) {
72378       {
72379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72380       };
72381     } catch (Dali::DaliException e) {
72382       {
72383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72384       };
72385     } catch (...) {
72386       {
72387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72388       };
72389     }
72390   }
72391
72392   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
72393
72394   //argout typemap for const std::string&
72395
72396   return jresult;
72397 }
72398
72399
72400 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_3(char * jarg1, void * jarg2) {
72401   void * jresult ;
72402   std::string *arg1 = 0 ;
72403   Dali::ImageDimensions arg2 ;
72404   Dali::ImageDimensions *argp2 ;
72405   Dali::Toolkit::ImageView result;
72406
72407   if (!jarg1) {
72408     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72409     return 0;
72410   }
72411   std::string arg1_str(jarg1);
72412   arg1 = &arg1_str;
72413   argp2 = (Dali::ImageDimensions *)jarg2;
72414   if (!argp2) {
72415     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
72416     return 0;
72417   }
72418   arg2 = *argp2;
72419   {
72420     try {
72421       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1,arg2);
72422     } catch (std::out_of_range& e) {
72423       {
72424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72425       };
72426     } catch (std::exception& e) {
72427       {
72428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72429       };
72430     } catch (Dali::DaliException e) {
72431       {
72432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72433       };
72434     } catch (...) {
72435       {
72436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72437       };
72438     }
72439   }
72440
72441   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
72442
72443   //argout typemap for const std::string&
72444
72445   return jresult;
72446 }
72447
72448
72449 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView(void * jarg1) {
72450   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72451
72452   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72453   {
72454     try {
72455       delete arg1;
72456     } catch (std::out_of_range& e) {
72457       {
72458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72459       };
72460     } catch (std::exception& e) {
72461       {
72462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72463       };
72464     } catch (Dali::DaliException e) {
72465       {
72466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72467       };
72468     } catch (...) {
72469       {
72470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72471       };
72472     }
72473   }
72474
72475 }
72476
72477
72478 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_1(void * jarg1) {
72479   void * jresult ;
72480   Dali::Toolkit::ImageView *arg1 = 0 ;
72481   Dali::Toolkit::ImageView *result = 0 ;
72482
72483   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72484   if (!arg1) {
72485     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
72486     return 0;
72487   }
72488   {
72489     try {
72490       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView((Dali::Toolkit::ImageView const &)*arg1);
72491     } catch (std::out_of_range& e) {
72492       {
72493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72494       };
72495     } catch (std::exception& e) {
72496       {
72497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72498       };
72499     } catch (Dali::DaliException e) {
72500       {
72501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72502       };
72503     } catch (...) {
72504       {
72505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72506       };
72507     }
72508   }
72509
72510   jresult = (void *)result;
72511   return jresult;
72512 }
72513
72514
72515 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_Assign(void * jarg1, void * jarg2) {
72516   void * jresult ;
72517   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72518   Dali::Toolkit::ImageView *arg2 = 0 ;
72519   Dali::Toolkit::ImageView *result = 0 ;
72520
72521   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72522   arg2 = (Dali::Toolkit::ImageView *)jarg2;
72523   if (!arg2) {
72524     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
72525     return 0;
72526   }
72527   {
72528     try {
72529       result = (Dali::Toolkit::ImageView *) &(arg1)->operator =((Dali::Toolkit::ImageView const &)*arg2);
72530     } catch (std::out_of_range& e) {
72531       {
72532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72533       };
72534     } catch (std::exception& e) {
72535       {
72536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72537       };
72538     } catch (Dali::DaliException e) {
72539       {
72540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72541       };
72542     } catch (...) {
72543       {
72544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72545       };
72546     }
72547   }
72548
72549   jresult = (void *)result;
72550   return jresult;
72551 }
72552
72553
72554 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_DownCast(void * jarg1) {
72555   void * jresult ;
72556   Dali::BaseHandle arg1 ;
72557   Dali::BaseHandle *argp1 ;
72558   Dali::Toolkit::ImageView result;
72559
72560   argp1 = (Dali::BaseHandle *)jarg1;
72561   if (!argp1) {
72562     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
72563     return 0;
72564   }
72565   arg1 = *argp1;
72566   {
72567     try {
72568       result = Dali::Toolkit::ImageView::DownCast(arg1);
72569     } catch (std::out_of_range& e) {
72570       {
72571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72572       };
72573     } catch (std::exception& e) {
72574       {
72575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72576       };
72577     } catch (Dali::DaliException e) {
72578       {
72579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72580       };
72581     } catch (...) {
72582       {
72583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72584       };
72585     }
72586   }
72587
72588   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
72589   return jresult;
72590 }
72591
72592
72593 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_0(void * jarg1, void * jarg2) {
72594   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72595   Dali::Image arg2 ;
72596   Dali::Image *argp2 ;
72597
72598   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72599   argp2 = (Dali::Image *)jarg2;
72600   if (!argp2) {
72601     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
72602     return ;
72603   }
72604   arg2 = *argp2;
72605   {
72606     try {
72607       (arg1)->SetImage(arg2);
72608     } catch (std::out_of_range& e) {
72609       {
72610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72611       };
72612     } catch (std::exception& e) {
72613       {
72614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72615       };
72616     } catch (Dali::DaliException e) {
72617       {
72618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72619       };
72620     } catch (...) {
72621       {
72622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72623       };
72624     }
72625   }
72626
72627 }
72628
72629
72630 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_1(void * jarg1, char * jarg2) {
72631   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72632   std::string *arg2 = 0 ;
72633
72634   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72635   if (!jarg2) {
72636     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72637     return ;
72638   }
72639   std::string arg2_str(jarg2);
72640   arg2 = &arg2_str;
72641   {
72642     try {
72643       (arg1)->SetImage((std::string const &)*arg2);
72644     } catch (std::out_of_range& e) {
72645       {
72646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72647       };
72648     } catch (std::exception& e) {
72649       {
72650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72651       };
72652     } catch (Dali::DaliException e) {
72653       {
72654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72655       };
72656     } catch (...) {
72657       {
72658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72659       };
72660     }
72661   }
72662
72663
72664   //argout typemap for const std::string&
72665
72666 }
72667
72668
72669 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
72670   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72671   std::string *arg2 = 0 ;
72672   Dali::ImageDimensions arg3 ;
72673   Dali::ImageDimensions *argp3 ;
72674
72675   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72676   if (!jarg2) {
72677     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72678     return ;
72679   }
72680   std::string arg2_str(jarg2);
72681   arg2 = &arg2_str;
72682   argp3 = (Dali::ImageDimensions *)jarg3;
72683   if (!argp3) {
72684     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
72685     return ;
72686   }
72687   arg3 = *argp3;
72688   {
72689     try {
72690       (arg1)->SetImage((std::string const &)*arg2,arg3);
72691     } catch (std::out_of_range& e) {
72692       {
72693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72694       };
72695     } catch (std::exception& e) {
72696       {
72697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72698       };
72699     } catch (Dali::DaliException e) {
72700       {
72701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72702       };
72703     } catch (...) {
72704       {
72705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72706       };
72707     }
72708   }
72709
72710
72711   //argout typemap for const std::string&
72712
72713 }
72714
72715 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_GetImage(void * jarg1) {
72716   void * jresult ;
72717   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72718   Dali::Image result;
72719
72720   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72721   {
72722     try {
72723       result = ((Dali::Toolkit::ImageView const *)arg1)->GetImage();
72724     } catch (std::out_of_range& e) {
72725       {
72726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72727       };
72728     } catch (std::exception& e) {
72729       {
72730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72731       };
72732     } catch (Dali::DaliException e) {
72733       {
72734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72735       };
72736     } catch (...) {
72737       {
72738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72739       };
72740     }
72741   }
72742
72743   jresult = new Dali::Image((const Dali::Image &)result);
72744   return jresult;
72745 }
72746
72747
72748 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_GEOMETRY_URL_get() {
72749   int jresult ;
72750   int result;
72751
72752   result = (int)Dali::Toolkit::Model3dView::Property::GEOMETRY_URL;
72753   jresult = (int)result;
72754   return jresult;
72755 }
72756
72757
72758 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_MATERIAL_URL_get() {
72759   int jresult ;
72760   int result;
72761
72762   result = (int)Dali::Toolkit::Model3dView::Property::MATERIAL_URL;
72763   jresult = (int)result;
72764   return jresult;
72765 }
72766
72767
72768 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_IMAGES_URL_get() {
72769   int jresult ;
72770   int result;
72771
72772   result = (int)Dali::Toolkit::Model3dView::Property::IMAGES_URL;
72773   jresult = (int)result;
72774   return jresult;
72775 }
72776
72777
72778 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_ILLUMINATION_TYPE_get() {
72779   int jresult ;
72780   int result;
72781
72782   result = (int)Dali::Toolkit::Model3dView::Property::ILLUMINATION_TYPE;
72783   jresult = (int)result;
72784   return jresult;
72785 }
72786
72787
72788 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE0_URL_get() {
72789   int jresult ;
72790   int result;
72791
72792   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE0_URL;
72793   jresult = (int)result;
72794   return jresult;
72795 }
72796
72797
72798 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE1_URL_get() {
72799   int jresult ;
72800   int result;
72801
72802   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE1_URL;
72803   jresult = (int)result;
72804   return jresult;
72805 }
72806
72807
72808 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE2_URL_get() {
72809   int jresult ;
72810   int result;
72811
72812   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE2_URL;
72813   jresult = (int)result;
72814   return jresult;
72815 }
72816
72817
72818 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_LIGHT_POSITION_get() {
72819   int jresult ;
72820   int result;
72821
72822   result = (int)Dali::Toolkit::Model3dView::Property::LIGHT_POSITION;
72823   jresult = (int)result;
72824   return jresult;
72825 }
72826
72827
72828 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView_Property() {
72829   void * jresult ;
72830   Dali::Toolkit::Model3dView::Property *result = 0 ;
72831
72832   {
72833     try {
72834       result = (Dali::Toolkit::Model3dView::Property *)new Dali::Toolkit::Model3dView::Property();
72835     } catch (std::out_of_range& e) {
72836       {
72837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72838       };
72839     } catch (std::exception& e) {
72840       {
72841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72842       };
72843     } catch (Dali::DaliException e) {
72844       {
72845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72846       };
72847     } catch (...) {
72848       {
72849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72850       };
72851     }
72852   }
72853
72854   jresult = (void *)result;
72855   return jresult;
72856 }
72857
72858
72859 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView_Property(void * jarg1) {
72860   Dali::Toolkit::Model3dView::Property *arg1 = (Dali::Toolkit::Model3dView::Property *) 0 ;
72861
72862   arg1 = (Dali::Toolkit::Model3dView::Property *)jarg1;
72863   {
72864     try {
72865       delete arg1;
72866     } catch (std::out_of_range& e) {
72867       {
72868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72869       };
72870     } catch (std::exception& e) {
72871       {
72872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72873       };
72874     } catch (Dali::DaliException e) {
72875       {
72876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72877       };
72878     } catch (...) {
72879       {
72880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72881       };
72882     }
72883   }
72884
72885 }
72886
72887
72888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_0() {
72889   void * jresult ;
72890   Dali::Toolkit::Model3dView result;
72891
72892   {
72893     try {
72894       result = Dali::Toolkit::Model3dView::New();
72895     } catch (std::out_of_range& e) {
72896       {
72897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72898       };
72899     } catch (std::exception& e) {
72900       {
72901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72902       };
72903     } catch (Dali::DaliException e) {
72904       {
72905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72906       };
72907     } catch (...) {
72908       {
72909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72910       };
72911     }
72912   }
72913
72914   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
72915   return jresult;
72916 }
72917
72918
72919 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_1(char * jarg1, char * jarg2, char * jarg3) {
72920   void * jresult ;
72921   std::string *arg1 = 0 ;
72922   std::string *arg2 = 0 ;
72923   std::string *arg3 = 0 ;
72924   Dali::Toolkit::Model3dView result;
72925
72926   if (!jarg1) {
72927     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72928     return 0;
72929   }
72930   std::string arg1_str(jarg1);
72931   arg1 = &arg1_str;
72932   if (!jarg2) {
72933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72934     return 0;
72935   }
72936   std::string arg2_str(jarg2);
72937   arg2 = &arg2_str;
72938   if (!jarg3) {
72939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72940     return 0;
72941   }
72942   std::string arg3_str(jarg3);
72943   arg3 = &arg3_str;
72944   {
72945     try {
72946       result = Dali::Toolkit::Model3dView::New((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3);
72947     } catch (std::out_of_range& e) {
72948       {
72949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72950       };
72951     } catch (std::exception& e) {
72952       {
72953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72954       };
72955     } catch (Dali::DaliException e) {
72956       {
72957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72958       };
72959     } catch (...) {
72960       {
72961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72962       };
72963     }
72964   }
72965
72966   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
72967
72968   //argout typemap for const std::string&
72969
72970
72971   //argout typemap for const std::string&
72972
72973
72974   //argout typemap for const std::string&
72975
72976   return jresult;
72977 }
72978
72979
72980 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_0() {
72981   void * jresult ;
72982   Dali::Toolkit::Model3dView *result = 0 ;
72983
72984   {
72985     try {
72986       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView();
72987     } catch (std::out_of_range& e) {
72988       {
72989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72990       };
72991     } catch (std::exception& e) {
72992       {
72993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72994       };
72995     } catch (Dali::DaliException e) {
72996       {
72997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72998       };
72999     } catch (...) {
73000       {
73001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73002       };
73003     }
73004   }
73005
73006   jresult = (void *)result;
73007   return jresult;
73008 }
73009
73010
73011 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView(void * jarg1) {
73012   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
73013
73014   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
73015   {
73016     try {
73017       delete arg1;
73018     } catch (std::out_of_range& e) {
73019       {
73020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73021       };
73022     } catch (std::exception& e) {
73023       {
73024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73025       };
73026     } catch (Dali::DaliException e) {
73027       {
73028         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73029       };
73030     } catch (...) {
73031       {
73032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73033       };
73034     }
73035   }
73036
73037 }
73038
73039
73040 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_1(void * jarg1) {
73041   void * jresult ;
73042   Dali::Toolkit::Model3dView *arg1 = 0 ;
73043   Dali::Toolkit::Model3dView *result = 0 ;
73044
73045   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
73046   if (!arg1) {
73047     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
73048     return 0;
73049   }
73050   {
73051     try {
73052       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView((Dali::Toolkit::Model3dView const &)*arg1);
73053     } catch (std::out_of_range& e) {
73054       {
73055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73056       };
73057     } catch (std::exception& e) {
73058       {
73059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73060       };
73061     } catch (Dali::DaliException e) {
73062       {
73063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73064       };
73065     } catch (...) {
73066       {
73067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73068       };
73069     }
73070   }
73071
73072   jresult = (void *)result;
73073   return jresult;
73074 }
73075
73076
73077 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_Assign(void * jarg1, void * jarg2) {
73078   void * jresult ;
73079   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
73080   Dali::Toolkit::Model3dView *arg2 = 0 ;
73081   Dali::Toolkit::Model3dView *result = 0 ;
73082
73083   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
73084   arg2 = (Dali::Toolkit::Model3dView *)jarg2;
73085   if (!arg2) {
73086     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
73087     return 0;
73088   }
73089   {
73090     try {
73091       result = (Dali::Toolkit::Model3dView *) &(arg1)->operator =((Dali::Toolkit::Model3dView const &)*arg2);
73092     } catch (std::out_of_range& e) {
73093       {
73094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73095       };
73096     } catch (std::exception& e) {
73097       {
73098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73099       };
73100     } catch (Dali::DaliException e) {
73101       {
73102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73103       };
73104     } catch (...) {
73105       {
73106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73107       };
73108     }
73109   }
73110
73111   jresult = (void *)result;
73112   return jresult;
73113 }
73114
73115
73116 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_DownCast(void * jarg1) {
73117   void * jresult ;
73118   Dali::BaseHandle arg1 ;
73119   Dali::BaseHandle *argp1 ;
73120   Dali::Toolkit::Model3dView result;
73121
73122   argp1 = (Dali::BaseHandle *)jarg1;
73123   if (!argp1) {
73124     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
73125     return 0;
73126   }
73127   arg1 = *argp1;
73128   {
73129     try {
73130       result = Dali::Toolkit::Model3dView::DownCast(arg1);
73131     } catch (std::out_of_range& e) {
73132       {
73133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73134       };
73135     } catch (std::exception& e) {
73136       {
73137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73138       };
73139     } catch (Dali::DaliException e) {
73140       {
73141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73142       };
73143     } catch (...) {
73144       {
73145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73146       };
73147     }
73148   }
73149
73150   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
73151   return jresult;
73152 }
73153
73154
73155 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_DIRECTION_get() {
73156   int jresult ;
73157   int result;
73158
73159   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_DIRECTION;
73160   jresult = (int)result;
73161   return jresult;
73162 }
73163
73164
73165 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HEIGHT_POLICY_get() {
73166   int jresult ;
73167   int result;
73168
73169   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HEIGHT_POLICY;
73170   jresult = (int)result;
73171   return jresult;
73172 }
73173
73174
73175 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_FIXED_HEIGHT_get() {
73176   int jresult ;
73177   int result;
73178
73179   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_FIXED_HEIGHT;
73180   jresult = (int)result;
73181   return jresult;
73182 }
73183
73184
73185 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_SHOW_DURATION_get() {
73186   int jresult ;
73187   int result;
73188
73189   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_SHOW_DURATION;
73190   jresult = (int)result;
73191   return jresult;
73192 }
73193
73194
73195 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HIDE_DURATION_get() {
73196   int jresult ;
73197   int result;
73198
73199   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HIDE_DURATION;
73200   jresult = (int)result;
73201   return jresult;
73202 }
73203
73204
73205 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_POSITION_INTERVALS_get() {
73206   int jresult ;
73207   int result;
73208
73209   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_POSITION_INTERVALS;
73210   jresult = (int)result;
73211   return jresult;
73212 }
73213
73214
73215 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_MINIMUM_HEIGHT_get() {
73216   int jresult ;
73217   int result;
73218
73219   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_MINIMUM_HEIGHT;
73220   jresult = (int)result;
73221   return jresult;
73222 }
73223
73224
73225 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_START_PADDING_get() {
73226   int jresult ;
73227   int result;
73228
73229   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_START_PADDING;
73230   jresult = (int)result;
73231   return jresult;
73232 }
73233
73234
73235 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_END_PADDING_get() {
73236   int jresult ;
73237   int result;
73238
73239   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_END_PADDING;
73240   jresult = (int)result;
73241   return jresult;
73242 }
73243
73244
73245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar_Property() {
73246   void * jresult ;
73247   Dali::Toolkit::ScrollBar::Property *result = 0 ;
73248
73249   {
73250     try {
73251       result = (Dali::Toolkit::ScrollBar::Property *)new Dali::Toolkit::ScrollBar::Property();
73252     } catch (std::out_of_range& e) {
73253       {
73254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73255       };
73256     } catch (std::exception& e) {
73257       {
73258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73259       };
73260     } catch (Dali::DaliException e) {
73261       {
73262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73263       };
73264     } catch (...) {
73265       {
73266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73267       };
73268     }
73269   }
73270
73271   jresult = (void *)result;
73272   return jresult;
73273 }
73274
73275
73276 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar_Property(void * jarg1) {
73277   Dali::Toolkit::ScrollBar::Property *arg1 = (Dali::Toolkit::ScrollBar::Property *) 0 ;
73278
73279   arg1 = (Dali::Toolkit::ScrollBar::Property *)jarg1;
73280   {
73281     try {
73282       delete arg1;
73283     } catch (std::out_of_range& e) {
73284       {
73285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73286       };
73287     } catch (std::exception& e) {
73288       {
73289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73290       };
73291     } catch (Dali::DaliException e) {
73292       {
73293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73294       };
73295     } catch (...) {
73296       {
73297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73298       };
73299     }
73300   }
73301
73302 }
73303
73304
73305 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_0() {
73306   void * jresult ;
73307   Dali::Toolkit::ScrollBar *result = 0 ;
73308
73309   {
73310     try {
73311       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar();
73312     } catch (std::out_of_range& e) {
73313       {
73314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73315       };
73316     } catch (std::exception& e) {
73317       {
73318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73319       };
73320     } catch (Dali::DaliException e) {
73321       {
73322         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73323       };
73324     } catch (...) {
73325       {
73326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73327       };
73328     }
73329   }
73330
73331   jresult = (void *)result;
73332   return jresult;
73333 }
73334
73335
73336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_1(void * jarg1) {
73337   void * jresult ;
73338   Dali::Toolkit::ScrollBar *arg1 = 0 ;
73339   Dali::Toolkit::ScrollBar *result = 0 ;
73340
73341   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73342   if (!arg1) {
73343     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
73344     return 0;
73345   }
73346   {
73347     try {
73348       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar((Dali::Toolkit::ScrollBar const &)*arg1);
73349     } catch (std::out_of_range& e) {
73350       {
73351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73352       };
73353     } catch (std::exception& e) {
73354       {
73355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73356       };
73357     } catch (Dali::DaliException e) {
73358       {
73359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73360       };
73361     } catch (...) {
73362       {
73363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73364       };
73365     }
73366   }
73367
73368   jresult = (void *)result;
73369   return jresult;
73370 }
73371
73372
73373 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_Assign(void * jarg1, void * jarg2) {
73374   void * jresult ;
73375   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73376   Dali::Toolkit::ScrollBar *arg2 = 0 ;
73377   Dali::Toolkit::ScrollBar *result = 0 ;
73378
73379   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73380   arg2 = (Dali::Toolkit::ScrollBar *)jarg2;
73381   if (!arg2) {
73382     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
73383     return 0;
73384   }
73385   {
73386     try {
73387       result = (Dali::Toolkit::ScrollBar *) &(arg1)->operator =((Dali::Toolkit::ScrollBar const &)*arg2);
73388     } catch (std::out_of_range& e) {
73389       {
73390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73391       };
73392     } catch (std::exception& e) {
73393       {
73394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73395       };
73396     } catch (Dali::DaliException e) {
73397       {
73398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73399       };
73400     } catch (...) {
73401       {
73402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73403       };
73404     }
73405   }
73406
73407   jresult = (void *)result;
73408   return jresult;
73409 }
73410
73411
73412 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar(void * jarg1) {
73413   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73414
73415   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73416   {
73417     try {
73418       delete arg1;
73419     } catch (std::out_of_range& e) {
73420       {
73421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73422       };
73423     } catch (std::exception& e) {
73424       {
73425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73426       };
73427     } catch (Dali::DaliException e) {
73428       {
73429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73430       };
73431     } catch (...) {
73432       {
73433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73434       };
73435     }
73436   }
73437
73438 }
73439
73440
73441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_0(int jarg1) {
73442   void * jresult ;
73443   Dali::Toolkit::ScrollBar::Direction arg1 ;
73444   Dali::Toolkit::ScrollBar result;
73445
73446   arg1 = (Dali::Toolkit::ScrollBar::Direction)jarg1;
73447   {
73448     try {
73449       result = Dali::Toolkit::ScrollBar::New(arg1);
73450     } catch (std::out_of_range& e) {
73451       {
73452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73453       };
73454     } catch (std::exception& e) {
73455       {
73456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73457       };
73458     } catch (Dali::DaliException e) {
73459       {
73460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73461       };
73462     } catch (...) {
73463       {
73464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73465       };
73466     }
73467   }
73468
73469   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
73470   return jresult;
73471 }
73472
73473
73474 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_1() {
73475   void * jresult ;
73476   Dali::Toolkit::ScrollBar result;
73477
73478   {
73479     try {
73480       result = Dali::Toolkit::ScrollBar::New();
73481     } catch (std::out_of_range& e) {
73482       {
73483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73484       };
73485     } catch (std::exception& e) {
73486       {
73487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73488       };
73489     } catch (Dali::DaliException e) {
73490       {
73491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73492       };
73493     } catch (...) {
73494       {
73495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73496       };
73497     }
73498   }
73499
73500   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
73501   return jresult;
73502 }
73503
73504
73505 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_DownCast(void * jarg1) {
73506   void * jresult ;
73507   Dali::BaseHandle arg1 ;
73508   Dali::BaseHandle *argp1 ;
73509   Dali::Toolkit::ScrollBar result;
73510
73511   argp1 = (Dali::BaseHandle *)jarg1;
73512   if (!argp1) {
73513     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
73514     return 0;
73515   }
73516   arg1 = *argp1;
73517   {
73518     try {
73519       result = Dali::Toolkit::ScrollBar::DownCast(arg1);
73520     } catch (std::out_of_range& e) {
73521       {
73522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73523       };
73524     } catch (std::exception& e) {
73525       {
73526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73527       };
73528     } catch (Dali::DaliException e) {
73529       {
73530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73531       };
73532     } catch (...) {
73533       {
73534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73535       };
73536     }
73537   }
73538
73539   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
73540   return jresult;
73541 }
73542
73543
73544 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPropertySource(void * jarg1, void * jarg2, int jarg3, int jarg4, int jarg5, int jarg6) {
73545   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73546   Dali::Handle arg2 ;
73547   Dali::Property::Index arg3 ;
73548   Dali::Property::Index arg4 ;
73549   Dali::Property::Index arg5 ;
73550   Dali::Property::Index arg6 ;
73551   Dali::Handle *argp2 ;
73552
73553   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73554   argp2 = (Dali::Handle *)jarg2;
73555   if (!argp2) {
73556     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Handle", 0);
73557     return ;
73558   }
73559   arg2 = *argp2;
73560   arg3 = (Dali::Property::Index)jarg3;
73561   arg4 = (Dali::Property::Index)jarg4;
73562   arg5 = (Dali::Property::Index)jarg5;
73563   arg6 = (Dali::Property::Index)jarg6;
73564   {
73565     try {
73566       (arg1)->SetScrollPropertySource(arg2,arg3,arg4,arg5,arg6);
73567     } catch (std::out_of_range& e) {
73568       {
73569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73570       };
73571     } catch (std::exception& e) {
73572       {
73573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73574       };
73575     } catch (Dali::DaliException e) {
73576       {
73577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73578       };
73579     } catch (...) {
73580       {
73581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73582       };
73583     }
73584   }
73585
73586 }
73587
73588
73589 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollIndicator(void * jarg1, void * jarg2) {
73590   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73591   Dali::Actor arg2 ;
73592   Dali::Actor *argp2 ;
73593
73594   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73595   argp2 = (Dali::Actor *)jarg2;
73596   if (!argp2) {
73597     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
73598     return ;
73599   }
73600   arg2 = *argp2;
73601   {
73602     try {
73603       (arg1)->SetScrollIndicator(arg2);
73604     } catch (std::out_of_range& e) {
73605       {
73606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73607       };
73608     } catch (std::exception& e) {
73609       {
73610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73611       };
73612     } catch (Dali::DaliException e) {
73613       {
73614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73615       };
73616     } catch (...) {
73617       {
73618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73619       };
73620     }
73621   }
73622
73623 }
73624
73625
73626 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollIndicator(void * jarg1) {
73627   void * jresult ;
73628   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73629   Dali::Actor result;
73630
73631   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73632   {
73633     try {
73634       result = (arg1)->GetScrollIndicator();
73635     } catch (std::out_of_range& e) {
73636       {
73637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73638       };
73639     } catch (std::exception& e) {
73640       {
73641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73642       };
73643     } catch (Dali::DaliException e) {
73644       {
73645         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73646       };
73647     } catch (...) {
73648       {
73649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73650       };
73651     }
73652   }
73653
73654   jresult = new Dali::Actor((const Dali::Actor &)result);
73655   return jresult;
73656 }
73657
73658
73659 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPositionIntervals(void * jarg1, void * jarg2) {
73660   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73661   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg2 = 0 ;
73662
73663   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73664   arg2 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg2;
73665   if (!arg2) {
73666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
73667     return ;
73668   }
73669   {
73670     try {
73671       (arg1)->SetScrollPositionIntervals((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg2);
73672     } catch (std::out_of_range& e) {
73673       {
73674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73675       };
73676     } catch (std::exception& e) {
73677       {
73678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73679       };
73680     } catch (Dali::DaliException e) {
73681       {
73682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73683       };
73684     } catch (...) {
73685       {
73686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73687       };
73688     }
73689   }
73690
73691 }
73692
73693
73694 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollPositionIntervals(void * jarg1) {
73695   void * jresult ;
73696   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73697
73698   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73699   {
73700     try {
73701       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()));
73702     } catch (std::out_of_range& e) {
73703       {
73704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73705       };
73706     } catch (std::exception& e) {
73707       {
73708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73709       };
73710     } catch (...) {
73711       {
73712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73713       };
73714     }
73715   }
73716   return jresult;
73717 }
73718
73719
73720 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollDirection(void * jarg1, int jarg2) {
73721   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73722   Dali::Toolkit::ScrollBar::Direction arg2 ;
73723
73724   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73725   arg2 = (Dali::Toolkit::ScrollBar::Direction)jarg2;
73726   {
73727     try {
73728       (arg1)->SetScrollDirection(arg2);
73729     } catch (std::out_of_range& e) {
73730       {
73731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73732       };
73733     } catch (std::exception& e) {
73734       {
73735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73736       };
73737     } catch (Dali::DaliException e) {
73738       {
73739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73740       };
73741     } catch (...) {
73742       {
73743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73744       };
73745     }
73746   }
73747
73748 }
73749
73750
73751 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollDirection(void * jarg1) {
73752   int jresult ;
73753   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73754   Dali::Toolkit::ScrollBar::Direction result;
73755
73756   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73757   {
73758     try {
73759       result = (Dali::Toolkit::ScrollBar::Direction)((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollDirection();
73760     } catch (std::out_of_range& e) {
73761       {
73762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73763       };
73764     } catch (std::exception& e) {
73765       {
73766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73767       };
73768     } catch (Dali::DaliException e) {
73769       {
73770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73771       };
73772     } catch (...) {
73773       {
73774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73775       };
73776     }
73777   }
73778
73779   jresult = (int)result;
73780   return jresult;
73781 }
73782
73783
73784 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHeightPolicy(void * jarg1, int jarg2) {
73785   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73786   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy arg2 ;
73787
73788   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73789   arg2 = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)jarg2;
73790   {
73791     try {
73792       (arg1)->SetIndicatorHeightPolicy(arg2);
73793     } catch (std::out_of_range& e) {
73794       {
73795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73796       };
73797     } catch (std::exception& e) {
73798       {
73799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73800       };
73801     } catch (Dali::DaliException e) {
73802       {
73803         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73804       };
73805     } catch (...) {
73806       {
73807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73808       };
73809     }
73810   }
73811
73812 }
73813
73814
73815 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHeightPolicy(void * jarg1) {
73816   int jresult ;
73817   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73818   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy result;
73819
73820   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73821   {
73822     try {
73823       result = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHeightPolicy();
73824     } catch (std::out_of_range& e) {
73825       {
73826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73827       };
73828     } catch (std::exception& e) {
73829       {
73830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73831       };
73832     } catch (Dali::DaliException e) {
73833       {
73834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73835       };
73836     } catch (...) {
73837       {
73838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73839       };
73840     }
73841   }
73842
73843   jresult = (int)result;
73844   return jresult;
73845 }
73846
73847
73848 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorFixedHeight(void * jarg1, float jarg2) {
73849   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73850   float arg2 ;
73851
73852   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73853   arg2 = (float)jarg2;
73854   {
73855     try {
73856       (arg1)->SetIndicatorFixedHeight(arg2);
73857     } catch (std::out_of_range& e) {
73858       {
73859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73860       };
73861     } catch (std::exception& e) {
73862       {
73863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73864       };
73865     } catch (Dali::DaliException e) {
73866       {
73867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73868       };
73869     } catch (...) {
73870       {
73871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73872       };
73873     }
73874   }
73875
73876 }
73877
73878
73879 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorFixedHeight(void * jarg1) {
73880   float jresult ;
73881   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73882   float result;
73883
73884   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73885   {
73886     try {
73887       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorFixedHeight();
73888     } catch (std::out_of_range& e) {
73889       {
73890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73891       };
73892     } catch (std::exception& e) {
73893       {
73894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73895       };
73896     } catch (Dali::DaliException e) {
73897       {
73898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73899       };
73900     } catch (...) {
73901       {
73902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73903       };
73904     }
73905   }
73906
73907   jresult = result;
73908   return jresult;
73909 }
73910
73911
73912 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorShowDuration(void * jarg1, float jarg2) {
73913   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73914   float arg2 ;
73915
73916   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73917   arg2 = (float)jarg2;
73918   {
73919     try {
73920       (arg1)->SetIndicatorShowDuration(arg2);
73921     } catch (std::out_of_range& e) {
73922       {
73923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73924       };
73925     } catch (std::exception& e) {
73926       {
73927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73928       };
73929     } catch (Dali::DaliException e) {
73930       {
73931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73932       };
73933     } catch (...) {
73934       {
73935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73936       };
73937     }
73938   }
73939
73940 }
73941
73942
73943 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorShowDuration(void * jarg1) {
73944   float jresult ;
73945   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73946   float result;
73947
73948   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73949   {
73950     try {
73951       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorShowDuration();
73952     } catch (std::out_of_range& e) {
73953       {
73954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73955       };
73956     } catch (std::exception& e) {
73957       {
73958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73959       };
73960     } catch (Dali::DaliException e) {
73961       {
73962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73963       };
73964     } catch (...) {
73965       {
73966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73967       };
73968     }
73969   }
73970
73971   jresult = result;
73972   return jresult;
73973 }
73974
73975
73976 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHideDuration(void * jarg1, float jarg2) {
73977   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73978   float arg2 ;
73979
73980   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73981   arg2 = (float)jarg2;
73982   {
73983     try {
73984       (arg1)->SetIndicatorHideDuration(arg2);
73985     } catch (std::out_of_range& e) {
73986       {
73987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73988       };
73989     } catch (std::exception& e) {
73990       {
73991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73992       };
73993     } catch (Dali::DaliException e) {
73994       {
73995         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73996       };
73997     } catch (...) {
73998       {
73999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74000       };
74001     }
74002   }
74003
74004 }
74005
74006
74007 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHideDuration(void * jarg1) {
74008   float jresult ;
74009   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
74010   float result;
74011
74012   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
74013   {
74014     try {
74015       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHideDuration();
74016     } catch (std::out_of_range& e) {
74017       {
74018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74019       };
74020     } catch (std::exception& e) {
74021       {
74022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74023       };
74024     } catch (Dali::DaliException e) {
74025       {
74026         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74027       };
74028     } catch (...) {
74029       {
74030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74031       };
74032     }
74033   }
74034
74035   jresult = result;
74036   return jresult;
74037 }
74038
74039
74040 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_ShowIndicator(void * jarg1) {
74041   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
74042
74043   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
74044   {
74045     try {
74046       (arg1)->ShowIndicator();
74047     } catch (std::out_of_range& e) {
74048       {
74049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74050       };
74051     } catch (std::exception& e) {
74052       {
74053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74054       };
74055     } catch (Dali::DaliException e) {
74056       {
74057         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74058       };
74059     } catch (...) {
74060       {
74061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74062       };
74063     }
74064   }
74065
74066 }
74067
74068
74069 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_HideIndicator(void * jarg1) {
74070   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
74071
74072   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
74073   {
74074     try {
74075       (arg1)->HideIndicator();
74076     } catch (std::out_of_range& e) {
74077       {
74078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74079       };
74080     } catch (std::exception& e) {
74081       {
74082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74083       };
74084     } catch (Dali::DaliException e) {
74085       {
74086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74087       };
74088     } catch (...) {
74089       {
74090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74091       };
74092     }
74093   }
74094
74095 }
74096
74097
74098 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_PanFinishedSignal(void * jarg1) {
74099   void * jresult ;
74100   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
74101   Dali::Toolkit::ScrollBar::PanFinishedSignalType *result = 0 ;
74102
74103   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
74104   {
74105     try {
74106       result = (Dali::Toolkit::ScrollBar::PanFinishedSignalType *) &(arg1)->PanFinishedSignal();
74107     } catch (std::out_of_range& e) {
74108       {
74109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74110       };
74111     } catch (std::exception& e) {
74112       {
74113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74114       };
74115     } catch (Dali::DaliException e) {
74116       {
74117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74118       };
74119     } catch (...) {
74120       {
74121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74122       };
74123     }
74124   }
74125
74126   jresult = (void *)result;
74127   return jresult;
74128 }
74129
74130
74131 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_ScrollPositionIntervalReachedSignal(void * jarg1) {
74132   void * jresult ;
74133   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
74134   Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *result = 0 ;
74135
74136   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
74137   {
74138     try {
74139       result = (Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *) &(arg1)->ScrollPositionIntervalReachedSignal();
74140     } catch (std::out_of_range& e) {
74141       {
74142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74143       };
74144     } catch (std::exception& e) {
74145       {
74146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74147       };
74148     } catch (Dali::DaliException e) {
74149       {
74150         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74151       };
74152     } catch (...) {
74153       {
74154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74155       };
74156     }
74157   }
74158
74159   jresult = (void *)result;
74160   return jresult;
74161 }
74162
74163
74164 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_EFFECT_COLOR_get() {
74165   int jresult ;
74166   int result;
74167
74168   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_EFFECT_COLOR;
74169   jresult = (int)result;
74170   return jresult;
74171 }
74172
74173
74174 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ANIMATION_SPEED_get() {
74175   int jresult ;
74176   int result;
74177
74178   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ANIMATION_SPEED;
74179   jresult = (int)result;
74180   return jresult;
74181 }
74182
74183
74184 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ENABLED_get() {
74185   int jresult ;
74186   int result;
74187
74188   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ENABLED;
74189   jresult = (int)result;
74190   return jresult;
74191 }
74192
74193
74194 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_SIZE_get() {
74195   int jresult ;
74196   int result;
74197
74198   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_SIZE;
74199   jresult = (int)result;
74200   return jresult;
74201 }
74202
74203
74204 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_TO_ALPHA_FUNCTION_get() {
74205   int jresult ;
74206   int result;
74207
74208   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_TO_ALPHA_FUNCTION;
74209   jresult = (int)result;
74210   return jresult;
74211 }
74212
74213
74214 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_RELATIVE_POSITION_get() {
74215   int jresult ;
74216   int result;
74217
74218   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_RELATIVE_POSITION;
74219   jresult = (int)result;
74220   return jresult;
74221 }
74222
74223
74224 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_get() {
74225   int jresult ;
74226   int result;
74227
74228   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN;
74229   jresult = (int)result;
74230   return jresult;
74231 }
74232
74233
74234 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_X_get() {
74235   int jresult ;
74236   int result;
74237
74238   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_X;
74239   jresult = (int)result;
74240   return jresult;
74241 }
74242
74243
74244 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_Y_get() {
74245   int jresult ;
74246   int result;
74247
74248   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_Y;
74249   jresult = (int)result;
74250   return jresult;
74251 }
74252
74253
74254 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_get() {
74255   int jresult ;
74256   int result;
74257
74258   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX;
74259   jresult = (int)result;
74260   return jresult;
74261 }
74262
74263
74264 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_X_get() {
74265   int jresult ;
74266   int result;
74267
74268   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_X;
74269   jresult = (int)result;
74270   return jresult;
74271 }
74272
74273
74274 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_Y_get() {
74275   int jresult ;
74276   int result;
74277
74278   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_Y;
74279   jresult = (int)result;
74280   return jresult;
74281 }
74282
74283
74284 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_VERTICAL_get() {
74285   int jresult ;
74286   int result;
74287
74288   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_VERTICAL;
74289   jresult = (int)result;
74290   return jresult;
74291 }
74292
74293
74294 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_HORIZONTAL_get() {
74295   int jresult ;
74296   int result;
74297
74298   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_HORIZONTAL;
74299   jresult = (int)result;
74300   return jresult;
74301 }
74302
74303
74304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable_Property() {
74305   void * jresult ;
74306   Dali::Toolkit::Scrollable::Property *result = 0 ;
74307
74308   {
74309     try {
74310       result = (Dali::Toolkit::Scrollable::Property *)new Dali::Toolkit::Scrollable::Property();
74311     } catch (std::out_of_range& e) {
74312       {
74313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74314       };
74315     } catch (std::exception& e) {
74316       {
74317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74318       };
74319     } catch (Dali::DaliException e) {
74320       {
74321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74322       };
74323     } catch (...) {
74324       {
74325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74326       };
74327     }
74328   }
74329
74330   jresult = (void *)result;
74331   return jresult;
74332 }
74333
74334
74335 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable_Property(void * jarg1) {
74336   Dali::Toolkit::Scrollable::Property *arg1 = (Dali::Toolkit::Scrollable::Property *) 0 ;
74337
74338   arg1 = (Dali::Toolkit::Scrollable::Property *)jarg1;
74339   {
74340     try {
74341       delete arg1;
74342     } catch (std::out_of_range& e) {
74343       {
74344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74345       };
74346     } catch (std::exception& e) {
74347       {
74348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74349       };
74350     } catch (Dali::DaliException e) {
74351       {
74352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74353       };
74354     } catch (...) {
74355       {
74356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74357       };
74358     }
74359   }
74360
74361 }
74362
74363
74364 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_0() {
74365   void * jresult ;
74366   Dali::Toolkit::Scrollable *result = 0 ;
74367
74368   {
74369     try {
74370       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable();
74371     } catch (std::out_of_range& e) {
74372       {
74373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74374       };
74375     } catch (std::exception& e) {
74376       {
74377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74378       };
74379     } catch (Dali::DaliException e) {
74380       {
74381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74382       };
74383     } catch (...) {
74384       {
74385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74386       };
74387     }
74388   }
74389
74390   jresult = (void *)result;
74391   return jresult;
74392 }
74393
74394
74395 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_1(void * jarg1) {
74396   void * jresult ;
74397   Dali::Toolkit::Scrollable *arg1 = 0 ;
74398   Dali::Toolkit::Scrollable *result = 0 ;
74399
74400   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74401   if (!arg1) {
74402     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
74403     return 0;
74404   }
74405   {
74406     try {
74407       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable((Dali::Toolkit::Scrollable const &)*arg1);
74408     } catch (std::out_of_range& e) {
74409       {
74410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74411       };
74412     } catch (std::exception& e) {
74413       {
74414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74415       };
74416     } catch (Dali::DaliException e) {
74417       {
74418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74419       };
74420     } catch (...) {
74421       {
74422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74423       };
74424     }
74425   }
74426
74427   jresult = (void *)result;
74428   return jresult;
74429 }
74430
74431
74432 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_Assign(void * jarg1, void * jarg2) {
74433   void * jresult ;
74434   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74435   Dali::Toolkit::Scrollable *arg2 = 0 ;
74436   Dali::Toolkit::Scrollable *result = 0 ;
74437
74438   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74439   arg2 = (Dali::Toolkit::Scrollable *)jarg2;
74440   if (!arg2) {
74441     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
74442     return 0;
74443   }
74444   {
74445     try {
74446       result = (Dali::Toolkit::Scrollable *) &(arg1)->operator =((Dali::Toolkit::Scrollable const &)*arg2);
74447     } catch (std::out_of_range& e) {
74448       {
74449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74450       };
74451     } catch (std::exception& e) {
74452       {
74453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74454       };
74455     } catch (Dali::DaliException e) {
74456       {
74457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74458       };
74459     } catch (...) {
74460       {
74461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74462       };
74463     }
74464   }
74465
74466   jresult = (void *)result;
74467   return jresult;
74468 }
74469
74470
74471 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable(void * jarg1) {
74472   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74473
74474   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74475   {
74476     try {
74477       delete arg1;
74478     } catch (std::out_of_range& e) {
74479       {
74480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74481       };
74482     } catch (std::exception& e) {
74483       {
74484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74485       };
74486     } catch (Dali::DaliException e) {
74487       {
74488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74489       };
74490     } catch (...) {
74491       {
74492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74493       };
74494     }
74495   }
74496
74497 }
74498
74499
74500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_DownCast(void * jarg1) {
74501   void * jresult ;
74502   Dali::BaseHandle arg1 ;
74503   Dali::BaseHandle *argp1 ;
74504   Dali::Toolkit::Scrollable result;
74505
74506   argp1 = (Dali::BaseHandle *)jarg1;
74507   if (!argp1) {
74508     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
74509     return 0;
74510   }
74511   arg1 = *argp1;
74512   {
74513     try {
74514       result = Dali::Toolkit::Scrollable::DownCast(arg1);
74515     } catch (std::out_of_range& e) {
74516       {
74517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74518       };
74519     } catch (std::exception& e) {
74520       {
74521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74522       };
74523     } catch (Dali::DaliException e) {
74524       {
74525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74526       };
74527     } catch (...) {
74528       {
74529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74530       };
74531     }
74532   }
74533
74534   jresult = new Dali::Toolkit::Scrollable((const Dali::Toolkit::Scrollable &)result);
74535   return jresult;
74536 }
74537
74538
74539 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Scrollable_IsOvershootEnabled(void * jarg1) {
74540   unsigned int jresult ;
74541   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74542   bool result;
74543
74544   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74545   {
74546     try {
74547       result = (bool)((Dali::Toolkit::Scrollable const *)arg1)->IsOvershootEnabled();
74548     } catch (std::out_of_range& e) {
74549       {
74550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74551       };
74552     } catch (std::exception& e) {
74553       {
74554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74555       };
74556     } catch (Dali::DaliException e) {
74557       {
74558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74559       };
74560     } catch (...) {
74561       {
74562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74563       };
74564     }
74565   }
74566
74567   jresult = result;
74568   return jresult;
74569 }
74570
74571
74572 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEnabled(void * jarg1, unsigned int jarg2) {
74573   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74574   bool arg2 ;
74575
74576   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74577   arg2 = jarg2 ? true : false;
74578   {
74579     try {
74580       (arg1)->SetOvershootEnabled(arg2);
74581     } catch (std::out_of_range& e) {
74582       {
74583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74584       };
74585     } catch (std::exception& e) {
74586       {
74587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74588       };
74589     } catch (Dali::DaliException e) {
74590       {
74591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74592       };
74593     } catch (...) {
74594       {
74595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74596       };
74597     }
74598   }
74599
74600 }
74601
74602
74603 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEffectColor(void * jarg1, void * jarg2) {
74604   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74605   Dali::Vector4 *arg2 = 0 ;
74606
74607   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74608   arg2 = (Dali::Vector4 *)jarg2;
74609   if (!arg2) {
74610     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
74611     return ;
74612   }
74613   {
74614     try {
74615       (arg1)->SetOvershootEffectColor((Dali::Vector4 const &)*arg2);
74616     } catch (std::out_of_range& e) {
74617       {
74618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74619       };
74620     } catch (std::exception& e) {
74621       {
74622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74623       };
74624     } catch (Dali::DaliException e) {
74625       {
74626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74627       };
74628     } catch (...) {
74629       {
74630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74631       };
74632     }
74633   }
74634
74635 }
74636
74637
74638 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootEffectColor(void * jarg1) {
74639   void * jresult ;
74640   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74641   Dali::Vector4 result;
74642
74643   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74644   {
74645     try {
74646       result = ((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootEffectColor();
74647     } catch (std::out_of_range& e) {
74648       {
74649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74650       };
74651     } catch (std::exception& e) {
74652       {
74653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74654       };
74655     } catch (Dali::DaliException e) {
74656       {
74657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74658       };
74659     } catch (...) {
74660       {
74661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74662       };
74663     }
74664   }
74665
74666   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
74667   return jresult;
74668 }
74669
74670
74671 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootAnimationSpeed(void * jarg1, float jarg2) {
74672   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74673   float arg2 ;
74674
74675   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74676   arg2 = (float)jarg2;
74677   {
74678     try {
74679       (arg1)->SetOvershootAnimationSpeed(arg2);
74680     } catch (std::out_of_range& e) {
74681       {
74682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74683       };
74684     } catch (std::exception& e) {
74685       {
74686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74687       };
74688     } catch (Dali::DaliException e) {
74689       {
74690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74691       };
74692     } catch (...) {
74693       {
74694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74695       };
74696     }
74697   }
74698
74699 }
74700
74701
74702 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootAnimationSpeed(void * jarg1) {
74703   float jresult ;
74704   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74705   float result;
74706
74707   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74708   {
74709     try {
74710       result = (float)((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootAnimationSpeed();
74711     } catch (std::out_of_range& e) {
74712       {
74713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74714       };
74715     } catch (std::exception& e) {
74716       {
74717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74718       };
74719     } catch (Dali::DaliException e) {
74720       {
74721         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74722       };
74723     } catch (...) {
74724       {
74725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74726       };
74727     }
74728   }
74729
74730   jresult = result;
74731   return jresult;
74732 }
74733
74734
74735 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollStartedSignal(void * jarg1) {
74736   void * jresult ;
74737   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74738   Dali::Toolkit::Scrollable::ScrollStartedSignalType *result = 0 ;
74739
74740   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74741   {
74742     try {
74743       result = (Dali::Toolkit::Scrollable::ScrollStartedSignalType *) &(arg1)->ScrollStartedSignal();
74744     } catch (std::out_of_range& e) {
74745       {
74746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74747       };
74748     } catch (std::exception& e) {
74749       {
74750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74751       };
74752     } catch (Dali::DaliException e) {
74753       {
74754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74755       };
74756     } catch (...) {
74757       {
74758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74759       };
74760     }
74761   }
74762
74763   jresult = (void *)result;
74764   return jresult;
74765 }
74766
74767
74768 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollUpdatedSignal(void * jarg1) {
74769   void * jresult ;
74770   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74771   Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *result = 0 ;
74772
74773   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74774   {
74775     try {
74776       result = (Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *) &(arg1)->ScrollUpdatedSignal();
74777     } catch (std::out_of_range& e) {
74778       {
74779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74780       };
74781     } catch (std::exception& e) {
74782       {
74783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74784       };
74785     } catch (Dali::DaliException e) {
74786       {
74787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74788       };
74789     } catch (...) {
74790       {
74791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74792       };
74793     }
74794   }
74795
74796   jresult = (void *)result;
74797   return jresult;
74798 }
74799
74800
74801 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollCompletedSignal(void * jarg1) {
74802   void * jresult ;
74803   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74804   Dali::Toolkit::Scrollable::ScrollCompletedSignalType *result = 0 ;
74805
74806   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74807   {
74808     try {
74809       result = (Dali::Toolkit::Scrollable::ScrollCompletedSignalType *) &(arg1)->ScrollCompletedSignal();
74810     } catch (std::out_of_range& e) {
74811       {
74812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74813       };
74814     } catch (std::exception& e) {
74815       {
74816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74817       };
74818     } catch (Dali::DaliException e) {
74819       {
74820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74821       };
74822     } catch (...) {
74823       {
74824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74825       };
74826     }
74827   }
74828
74829   jresult = (void *)result;
74830   return jresult;
74831 }
74832
74833
74834 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsVertical(int jarg1) {
74835   unsigned int jresult ;
74836   Dali::Toolkit::ControlOrientation::Type arg1 ;
74837   bool result;
74838
74839   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
74840   {
74841     try {
74842       result = (bool)Dali::Toolkit::IsVertical(arg1);
74843     } catch (std::out_of_range& e) {
74844       {
74845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74846       };
74847     } catch (std::exception& e) {
74848       {
74849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74850       };
74851     } catch (Dali::DaliException e) {
74852       {
74853         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74854       };
74855     } catch (...) {
74856       {
74857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74858       };
74859     }
74860   }
74861
74862   jresult = result;
74863   return jresult;
74864 }
74865
74866
74867 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsHorizontal(int jarg1) {
74868   unsigned int jresult ;
74869   Dali::Toolkit::ControlOrientation::Type arg1 ;
74870   bool result;
74871
74872   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
74873   {
74874     try {
74875       result = (bool)Dali::Toolkit::IsHorizontal(arg1);
74876     } catch (std::out_of_range& e) {
74877       {
74878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74879       };
74880     } catch (std::exception& e) {
74881       {
74882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74883       };
74884     } catch (Dali::DaliException e) {
74885       {
74886         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74887       };
74888     } catch (...) {
74889       {
74890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74891       };
74892     }
74893   }
74894
74895   jresult = result;
74896   return jresult;
74897 }
74898
74899
74900 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_0(unsigned int jarg1, unsigned int jarg2) {
74901   void * jresult ;
74902   unsigned int arg1 ;
74903   unsigned int arg2 ;
74904   Dali::Toolkit::ItemRange *result = 0 ;
74905
74906   arg1 = (unsigned int)jarg1;
74907   arg2 = (unsigned int)jarg2;
74908   {
74909     try {
74910       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange(arg1,arg2);
74911     } catch (std::out_of_range& e) {
74912       {
74913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74914       };
74915     } catch (std::exception& e) {
74916       {
74917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74918       };
74919     } catch (Dali::DaliException e) {
74920       {
74921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74922       };
74923     } catch (...) {
74924       {
74925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74926       };
74927     }
74928   }
74929
74930   jresult = (void *)result;
74931   return jresult;
74932 }
74933
74934
74935 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_1(void * jarg1) {
74936   void * jresult ;
74937   Dali::Toolkit::ItemRange *arg1 = 0 ;
74938   Dali::Toolkit::ItemRange *result = 0 ;
74939
74940   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74941   if (!arg1) {
74942     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
74943     return 0;
74944   }
74945   {
74946     try {
74947       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange((Dali::Toolkit::ItemRange const &)*arg1);
74948     } catch (std::out_of_range& e) {
74949       {
74950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74951       };
74952     } catch (std::exception& e) {
74953       {
74954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74955       };
74956     } catch (Dali::DaliException e) {
74957       {
74958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74959       };
74960     } catch (...) {
74961       {
74962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74963       };
74964     }
74965   }
74966
74967   jresult = (void *)result;
74968   return jresult;
74969 }
74970
74971
74972 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Assign(void * jarg1, void * jarg2) {
74973   void * jresult ;
74974   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74975   Dali::Toolkit::ItemRange *arg2 = 0 ;
74976   Dali::Toolkit::ItemRange *result = 0 ;
74977
74978   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74979   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
74980   if (!arg2) {
74981     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
74982     return 0;
74983   }
74984   {
74985     try {
74986       result = (Dali::Toolkit::ItemRange *) &(arg1)->operator =((Dali::Toolkit::ItemRange const &)*arg2);
74987     } catch (std::out_of_range& e) {
74988       {
74989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74990       };
74991     } catch (std::exception& e) {
74992       {
74993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74994       };
74995     } catch (Dali::DaliException e) {
74996       {
74997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74998       };
74999     } catch (...) {
75000       {
75001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75002       };
75003     }
75004   }
75005
75006   jresult = (void *)result;
75007   return jresult;
75008 }
75009
75010
75011 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_Within(void * jarg1, unsigned int jarg2) {
75012   unsigned int jresult ;
75013   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
75014   unsigned int arg2 ;
75015   bool result;
75016
75017   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
75018   arg2 = (unsigned int)jarg2;
75019   {
75020     try {
75021       result = (bool)(arg1)->Within(arg2);
75022     } catch (std::out_of_range& e) {
75023       {
75024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75025       };
75026     } catch (std::exception& e) {
75027       {
75028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75029       };
75030     } catch (Dali::DaliException e) {
75031       {
75032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75033       };
75034     } catch (...) {
75035       {
75036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75037       };
75038     }
75039   }
75040
75041   jresult = result;
75042   return jresult;
75043 }
75044
75045
75046 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Intersection(void * jarg1, void * jarg2) {
75047   void * jresult ;
75048   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
75049   Dali::Toolkit::ItemRange *arg2 = 0 ;
75050   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
75051
75052   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
75053   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
75054   if (!arg2) {
75055     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
75056     return 0;
75057   }
75058   {
75059     try {
75060       result = (arg1)->Intersection((Dali::Toolkit::ItemRange const &)*arg2);
75061     } catch (std::out_of_range& e) {
75062       {
75063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75064       };
75065     } catch (std::exception& e) {
75066       {
75067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75068       };
75069     } catch (Dali::DaliException e) {
75070       {
75071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75072       };
75073     } catch (...) {
75074       {
75075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75076       };
75077     }
75078   }
75079
75080   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
75081   return jresult;
75082 }
75083
75084
75085 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_begin_set(void * jarg1, unsigned int jarg2) {
75086   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
75087   unsigned int arg2 ;
75088
75089   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
75090   arg2 = (unsigned int)jarg2;
75091   if (arg1) (arg1)->begin = arg2;
75092 }
75093
75094
75095 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_begin_get(void * jarg1) {
75096   unsigned int jresult ;
75097   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
75098   unsigned int result;
75099
75100   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
75101   result = (unsigned int) ((arg1)->begin);
75102   jresult = result;
75103   return jresult;
75104 }
75105
75106
75107 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_end_set(void * jarg1, unsigned int jarg2) {
75108   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
75109   unsigned int arg2 ;
75110
75111   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
75112   arg2 = (unsigned int)jarg2;
75113   if (arg1) (arg1)->end = arg2;
75114 }
75115
75116
75117 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_end_get(void * jarg1) {
75118   unsigned int jresult ;
75119   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
75120   unsigned int result;
75121
75122   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
75123   result = (unsigned int) ((arg1)->end);
75124   jresult = result;
75125   return jresult;
75126 }
75127
75128
75129 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemRange(void * jarg1) {
75130   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
75131
75132   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
75133   {
75134     try {
75135       delete arg1;
75136     } catch (std::out_of_range& e) {
75137       {
75138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75139       };
75140     } catch (std::exception& e) {
75141       {
75142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75143       };
75144     } catch (Dali::DaliException e) {
75145       {
75146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75147       };
75148     } catch (...) {
75149       {
75150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75151       };
75152     }
75153   }
75154
75155 }
75156
75157
75158 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemLayout(void * jarg1) {
75159   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75160
75161   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75162   {
75163     try {
75164       delete arg1;
75165     } catch (std::out_of_range& e) {
75166       {
75167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75168       };
75169     } catch (std::exception& e) {
75170       {
75171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75172       };
75173     } catch (Dali::DaliException e) {
75174       {
75175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75176       };
75177     } catch (...) {
75178       {
75179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75180       };
75181     }
75182   }
75183
75184 }
75185
75186
75187 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetOrientation(void * jarg1, int jarg2) {
75188   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75189   Dali::Toolkit::ControlOrientation::Type arg2 ;
75190
75191   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75192   arg2 = (Dali::Toolkit::ControlOrientation::Type)jarg2;
75193   {
75194     try {
75195       (arg1)->SetOrientation(arg2);
75196     } catch (std::out_of_range& e) {
75197       {
75198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75199       };
75200     } catch (std::exception& e) {
75201       {
75202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75203       };
75204     } catch (Dali::DaliException e) {
75205       {
75206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75207       };
75208     } catch (...) {
75209       {
75210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75211       };
75212     }
75213   }
75214
75215 }
75216
75217
75218 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetOrientation(void * jarg1) {
75219   int jresult ;
75220   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75221   Dali::Toolkit::ControlOrientation::Type result;
75222
75223   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75224   {
75225     try {
75226       result = (Dali::Toolkit::ControlOrientation::Type)((Dali::Toolkit::ItemLayout const *)arg1)->GetOrientation();
75227     } catch (std::out_of_range& e) {
75228       {
75229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75230       };
75231     } catch (std::exception& e) {
75232       {
75233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75234       };
75235     } catch (Dali::DaliException e) {
75236       {
75237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75238       };
75239     } catch (...) {
75240       {
75241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75242       };
75243     }
75244   }
75245
75246   jresult = (int)result;
75247   return jresult;
75248 }
75249
75250
75251 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetLayoutProperties(void * jarg1, void * jarg2) {
75252   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75253   Dali::Property::Map *arg2 = 0 ;
75254
75255   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75256   arg2 = (Dali::Property::Map *)jarg2;
75257   if (!arg2) {
75258     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
75259     return ;
75260   }
75261   {
75262     try {
75263       (arg1)->SetLayoutProperties((Dali::Property::Map const &)*arg2);
75264     } catch (std::out_of_range& e) {
75265       {
75266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75267       };
75268     } catch (std::exception& e) {
75269       {
75270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75271       };
75272     } catch (Dali::DaliException e) {
75273       {
75274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75275       };
75276     } catch (...) {
75277       {
75278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75279       };
75280     }
75281   }
75282
75283 }
75284
75285
75286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetLayoutProperties(void * jarg1) {
75287   void * jresult ;
75288   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75289   Dali::Property::Map result;
75290
75291   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75292   {
75293     try {
75294       result = (arg1)->GetLayoutProperties();
75295     } catch (std::out_of_range& e) {
75296       {
75297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75298       };
75299     } catch (std::exception& e) {
75300       {
75301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75302       };
75303     } catch (Dali::DaliException e) {
75304       {
75305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75306       };
75307     } catch (...) {
75308       {
75309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75310       };
75311     }
75312   }
75313
75314   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
75315   return jresult;
75316 }
75317
75318
75319 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
75320   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75321   unsigned int arg2 ;
75322   Dali::Vector3 *arg3 = 0 ;
75323   Dali::Vector3 *arg4 = 0 ;
75324
75325   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75326   arg2 = (unsigned int)jarg2;
75327   arg3 = (Dali::Vector3 *)jarg3;
75328   if (!arg3) {
75329     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75330     return ;
75331   }
75332   arg4 = (Dali::Vector3 *)jarg4;
75333   if (!arg4) {
75334     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
75335     return ;
75336   }
75337   {
75338     try {
75339       ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
75340     } catch (std::out_of_range& e) {
75341       {
75342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75343       };
75344     } catch (std::exception& e) {
75345       {
75346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75347       };
75348     } catch (Dali::DaliException e) {
75349       {
75350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75351       };
75352     } catch (...) {
75353       {
75354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75355       };
75356     }
75357   }
75358
75359 }
75360
75361
75362 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetItemSize(void * jarg1, void * jarg2) {
75363   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75364   Dali::Vector3 *arg2 = 0 ;
75365
75366   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75367   arg2 = (Dali::Vector3 *)jarg2;
75368   if (!arg2) {
75369     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75370     return ;
75371   }
75372   {
75373     try {
75374       (arg1)->SetItemSize((Dali::Vector3 const &)*arg2);
75375     } catch (std::out_of_range& e) {
75376       {
75377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75378       };
75379     } catch (std::exception& e) {
75380       {
75381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75382       };
75383     } catch (Dali::DaliException e) {
75384       {
75385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75386       };
75387     } catch (...) {
75388       {
75389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75390       };
75391     }
75392   }
75393
75394 }
75395
75396
75397 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMinimumLayoutPosition(void * jarg1, unsigned int jarg2, void * jarg3) {
75398   float jresult ;
75399   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75400   unsigned int arg2 ;
75401   Dali::Vector3 arg3 ;
75402   Dali::Vector3 *argp3 ;
75403   float result;
75404
75405   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75406   arg2 = (unsigned int)jarg2;
75407   argp3 = (Dali::Vector3 *)jarg3;
75408   if (!argp3) {
75409     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
75410     return 0;
75411   }
75412   arg3 = *argp3;
75413   {
75414     try {
75415       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMinimumLayoutPosition(arg2,arg3);
75416     } catch (std::out_of_range& e) {
75417       {
75418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75419       };
75420     } catch (std::exception& e) {
75421       {
75422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75423       };
75424     } catch (Dali::DaliException e) {
75425       {
75426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75427       };
75428     } catch (...) {
75429       {
75430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75431       };
75432     }
75433   }
75434
75435   jresult = result;
75436   return jresult;
75437 }
75438
75439
75440 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestAnchorPosition(void * jarg1, float jarg2) {
75441   float jresult ;
75442   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75443   float arg2 ;
75444   float result;
75445
75446   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75447   arg2 = (float)jarg2;
75448   {
75449     try {
75450       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetClosestAnchorPosition(arg2);
75451     } catch (std::out_of_range& e) {
75452       {
75453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75454       };
75455     } catch (std::exception& e) {
75456       {
75457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75458       };
75459     } catch (Dali::DaliException e) {
75460       {
75461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75462       };
75463     } catch (...) {
75464       {
75465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75466       };
75467     }
75468   }
75469
75470   jresult = result;
75471   return jresult;
75472 }
75473
75474
75475 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemScrollToPosition(void * jarg1, unsigned int jarg2) {
75476   float jresult ;
75477   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75478   unsigned int arg2 ;
75479   float result;
75480
75481   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75482   arg2 = (unsigned int)jarg2;
75483   {
75484     try {
75485       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemScrollToPosition(arg2);
75486     } catch (std::out_of_range& e) {
75487       {
75488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75489       };
75490     } catch (std::exception& e) {
75491       {
75492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75493       };
75494     } catch (Dali::DaliException e) {
75495       {
75496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75497       };
75498     } catch (...) {
75499       {
75500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75501       };
75502     }
75503   }
75504
75505   jresult = result;
75506   return jresult;
75507 }
75508
75509
75510 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemsWithinArea(void * jarg1, float jarg2, void * jarg3) {
75511   void * jresult ;
75512   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75513   float arg2 ;
75514   Dali::Vector3 arg3 ;
75515   Dali::Vector3 *argp3 ;
75516   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
75517
75518   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75519   arg2 = (float)jarg2;
75520   argp3 = (Dali::Vector3 *)jarg3;
75521   if (!argp3) {
75522     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
75523     return 0;
75524   }
75525   arg3 = *argp3;
75526   {
75527     try {
75528       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemsWithinArea(arg2,arg3);
75529     } catch (std::out_of_range& e) {
75530       {
75531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75532       };
75533     } catch (std::exception& e) {
75534       {
75535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75536       };
75537     } catch (Dali::DaliException e) {
75538       {
75539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75540       };
75541     } catch (...) {
75542       {
75543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75544       };
75545     }
75546   }
75547
75548   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
75549   return jresult;
75550 }
75551
75552
75553 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestOnScreenLayoutPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
75554   float jresult ;
75555   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75556   int arg2 ;
75557   float arg3 ;
75558   Dali::Vector3 *arg4 = 0 ;
75559   float result;
75560
75561   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75562   arg2 = (int)jarg2;
75563   arg3 = (float)jarg3;
75564   arg4 = (Dali::Vector3 *)jarg4;
75565   if (!arg4) {
75566     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75567     return 0;
75568   }
75569   {
75570     try {
75571       result = (float)(arg1)->GetClosestOnScreenLayoutPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
75572     } catch (std::out_of_range& e) {
75573       {
75574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75575       };
75576     } catch (std::exception& e) {
75577       {
75578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75579       };
75580     } catch (Dali::DaliException e) {
75581       {
75582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75583       };
75584     } catch (...) {
75585       {
75586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75587       };
75588     }
75589   }
75590
75591   jresult = result;
75592   return jresult;
75593 }
75594
75595
75596 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemLayout_GetReserveItemCount(void * jarg1, void * jarg2) {
75597   unsigned int jresult ;
75598   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75599   Dali::Vector3 arg2 ;
75600   Dali::Vector3 *argp2 ;
75601   unsigned int result;
75602
75603   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75604   argp2 = (Dali::Vector3 *)jarg2;
75605   if (!argp2) {
75606     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
75607     return 0;
75608   }
75609   arg2 = *argp2;
75610   {
75611     try {
75612       result = (unsigned int)((Dali::Toolkit::ItemLayout const *)arg1)->GetReserveItemCount(arg2);
75613     } catch (std::out_of_range& e) {
75614       {
75615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75616       };
75617     } catch (std::exception& e) {
75618       {
75619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75620       };
75621     } catch (Dali::DaliException e) {
75622       {
75623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75624       };
75625     } catch (...) {
75626       {
75627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75628       };
75629     }
75630   }
75631
75632   jresult = result;
75633   return jresult;
75634 }
75635
75636
75637 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetDefaultItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
75638   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75639   unsigned int arg2 ;
75640   Dali::Vector3 *arg3 = 0 ;
75641   Dali::Vector3 *arg4 = 0 ;
75642
75643   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75644   arg2 = (unsigned int)jarg2;
75645   arg3 = (Dali::Vector3 *)jarg3;
75646   if (!arg3) {
75647     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75648     return ;
75649   }
75650   arg4 = (Dali::Vector3 *)jarg4;
75651   if (!arg4) {
75652     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
75653     return ;
75654   }
75655   {
75656     try {
75657       ((Dali::Toolkit::ItemLayout const *)arg1)->GetDefaultItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
75658     } catch (std::out_of_range& e) {
75659       {
75660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75661       };
75662     } catch (std::exception& e) {
75663       {
75664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75665       };
75666     } catch (Dali::DaliException e) {
75667       {
75668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75669       };
75670     } catch (...) {
75671       {
75672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75673       };
75674     }
75675   }
75676
75677 }
75678
75679
75680 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollDirection(void * jarg1) {
75681   void * jresult ;
75682   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75683   Dali::Degree result;
75684
75685   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75686   {
75687     try {
75688       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollDirection();
75689     } catch (std::out_of_range& e) {
75690       {
75691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75692       };
75693     } catch (std::exception& e) {
75694       {
75695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75696       };
75697     } catch (Dali::DaliException e) {
75698       {
75699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75700       };
75701     } catch (...) {
75702       {
75703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75704       };
75705     }
75706   }
75707
75708   jresult = new Dali::Degree((const Dali::Degree &)result);
75709   return jresult;
75710 }
75711
75712
75713 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollSpeedFactor(void * jarg1) {
75714   float jresult ;
75715   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75716   float result;
75717
75718   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75719   {
75720     try {
75721       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollSpeedFactor();
75722     } catch (std::out_of_range& e) {
75723       {
75724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75725       };
75726     } catch (std::exception& e) {
75727       {
75728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75729       };
75730     } catch (Dali::DaliException e) {
75731       {
75732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75733       };
75734     } catch (...) {
75735       {
75736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75737       };
75738     }
75739   }
75740
75741   jresult = result;
75742   return jresult;
75743 }
75744
75745
75746 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMaximumSwipeSpeed(void * jarg1) {
75747   float jresult ;
75748   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75749   float result;
75750
75751   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75752   {
75753     try {
75754       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMaximumSwipeSpeed();
75755     } catch (std::out_of_range& e) {
75756       {
75757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75758       };
75759     } catch (std::exception& e) {
75760       {
75761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75762       };
75763     } catch (Dali::DaliException e) {
75764       {
75765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75766       };
75767     } catch (...) {
75768       {
75769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75770       };
75771     }
75772   }
75773
75774   jresult = result;
75775   return jresult;
75776 }
75777
75778
75779 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemFlickAnimationDuration(void * jarg1) {
75780   float jresult ;
75781   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75782   float result;
75783
75784   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75785   {
75786     try {
75787       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemFlickAnimationDuration();
75788     } catch (std::out_of_range& e) {
75789       {
75790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75791       };
75792     } catch (std::exception& e) {
75793       {
75794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75795       };
75796     } catch (Dali::DaliException e) {
75797       {
75798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75799       };
75800     } catch (...) {
75801       {
75802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75803       };
75804     }
75805   }
75806
75807   jresult = result;
75808   return jresult;
75809 }
75810
75811
75812 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetNextFocusItemID(void * jarg1, int jarg2, int jarg3, int jarg4, unsigned int jarg5) {
75813   int jresult ;
75814   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75815   int arg2 ;
75816   int arg3 ;
75817   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
75818   bool arg5 ;
75819   int result;
75820
75821   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75822   arg2 = (int)jarg2;
75823   arg3 = (int)jarg3;
75824   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
75825   arg5 = jarg5 ? true : false;
75826   {
75827     try {
75828       result = (int)(arg1)->GetNextFocusItemID(arg2,arg3,arg4,arg5);
75829     } catch (std::out_of_range& e) {
75830       {
75831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75832       };
75833     } catch (std::exception& e) {
75834       {
75835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75836       };
75837     } catch (Dali::DaliException e) {
75838       {
75839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75840       };
75841     } catch (...) {
75842       {
75843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75844       };
75845     }
75846   }
75847
75848   jresult = result;
75849   return jresult;
75850 }
75851
75852
75853 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetFlickSpeedFactor(void * jarg1) {
75854   float jresult ;
75855   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75856   float result;
75857
75858   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75859   {
75860     try {
75861       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetFlickSpeedFactor();
75862     } catch (std::out_of_range& e) {
75863       {
75864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75865       };
75866     } catch (std::exception& e) {
75867       {
75868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75869       };
75870     } catch (Dali::DaliException e) {
75871       {
75872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75873       };
75874     } catch (...) {
75875       {
75876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75877       };
75878     }
75879   }
75880
75881   jresult = result;
75882   return jresult;
75883 }
75884
75885
75886 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_ApplyConstraints(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5) {
75887   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75888   Dali::Actor *arg2 = 0 ;
75889   int arg3 ;
75890   Dali::Vector3 *arg4 = 0 ;
75891   Dali::Actor *arg5 = 0 ;
75892
75893   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75894   arg2 = (Dali::Actor *)jarg2;
75895   if (!arg2) {
75896     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
75897     return ;
75898   }
75899   arg3 = (int)jarg3;
75900   arg4 = (Dali::Vector3 *)jarg4;
75901   if (!arg4) {
75902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75903     return ;
75904   }
75905   arg5 = (Dali::Actor *)jarg5;
75906   if (!arg5) {
75907     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
75908     return ;
75909   }
75910   {
75911     try {
75912       (arg1)->ApplyConstraints(*arg2,arg3,(Dali::Vector3 const &)*arg4,(Dali::Actor const &)*arg5);
75913     } catch (std::out_of_range& e) {
75914       {
75915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75916       };
75917     } catch (std::exception& e) {
75918       {
75919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75920       };
75921     } catch (Dali::DaliException e) {
75922       {
75923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75924       };
75925     } catch (...) {
75926       {
75927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75928       };
75929     }
75930   }
75931
75932 }
75933
75934
75935 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
75936   void * jresult ;
75937   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75938   int arg2 ;
75939   float arg3 ;
75940   Dali::Vector3 *arg4 = 0 ;
75941   Dali::Vector3 result;
75942
75943   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75944   arg2 = (int)jarg2;
75945   arg3 = (float)jarg3;
75946   arg4 = (Dali::Vector3 *)jarg4;
75947   if (!arg4) {
75948     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75949     return 0;
75950   }
75951   {
75952     try {
75953       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
75954     } catch (std::out_of_range& e) {
75955       {
75956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75957       };
75958     } catch (std::exception& e) {
75959       {
75960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75961       };
75962     } catch (Dali::DaliException e) {
75963       {
75964         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75965       };
75966     } catch (...) {
75967       {
75968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75969       };
75970     }
75971   }
75972
75973   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
75974   return jresult;
75975 }
75976
75977
75978 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NewItemLayout(int jarg1) {
75979   void * jresult ;
75980   Dali::Toolkit::DefaultItemLayout::Type arg1 ;
75981   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
75982
75983   arg1 = (Dali::Toolkit::DefaultItemLayout::Type)jarg1;
75984   {
75985     try {
75986       result = Dali::Toolkit::DefaultItemLayout::New(arg1);
75987     } catch (std::out_of_range& e) {
75988       {
75989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75990       };
75991     } catch (std::exception& e) {
75992       {
75993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75994       };
75995     } catch (Dali::DaliException e) {
75996       {
75997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75998       };
75999     } catch (...) {
76000       {
76001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76002       };
76003     }
76004   }
76005
76006   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
76007   return jresult;
76008 }
76009
76010
76011 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemFactory(void * jarg1) {
76012   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
76013
76014   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
76015   {
76016     try {
76017       delete arg1;
76018     } catch (std::out_of_range& e) {
76019       {
76020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76021       };
76022     } catch (std::exception& e) {
76023       {
76024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76025       };
76026     } catch (Dali::DaliException e) {
76027       {
76028         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76029       };
76030     } catch (...) {
76031       {
76032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76033       };
76034     }
76035   }
76036
76037 }
76038
76039
76040 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemFactory_GetNumberOfItems(void * jarg1) {
76041   unsigned int jresult ;
76042   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
76043   unsigned int result;
76044
76045   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
76046   {
76047     try {
76048       result = (unsigned int)(arg1)->GetNumberOfItems();
76049     } catch (std::out_of_range& e) {
76050       {
76051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76052       };
76053     } catch (std::exception& e) {
76054       {
76055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76056       };
76057     } catch (Dali::DaliException e) {
76058       {
76059         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76060       };
76061     } catch (...) {
76062       {
76063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76064       };
76065     }
76066   }
76067
76068   jresult = result;
76069   return jresult;
76070 }
76071
76072
76073 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemFactory_NewItem(void * jarg1, unsigned int jarg2) {
76074   void * jresult ;
76075   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
76076   unsigned int arg2 ;
76077   Dali::Actor result;
76078
76079   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
76080   arg2 = (unsigned int)jarg2;
76081   {
76082     try {
76083       result = (arg1)->NewItem(arg2);
76084     } catch (std::out_of_range& e) {
76085       {
76086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76087       };
76088     } catch (std::exception& e) {
76089       {
76090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76091       };
76092     } catch (Dali::DaliException e) {
76093       {
76094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76095       };
76096     } catch (...) {
76097       {
76098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76099       };
76100     }
76101   }
76102
76103   jresult = new Dali::Actor((const Dali::Actor &)result);
76104   return jresult;
76105 }
76106
76107
76108 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleased(void * jarg1, unsigned int jarg2, void * jarg3) {
76109   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
76110   unsigned int arg2 ;
76111   Dali::Actor arg3 ;
76112   Dali::Actor *argp3 ;
76113
76114   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
76115   arg2 = (unsigned int)jarg2;
76116   argp3 = (Dali::Actor *)jarg3;
76117   if (!argp3) {
76118     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76119     return ;
76120   }
76121   arg3 = *argp3;
76122   {
76123     try {
76124       (arg1)->ItemReleased(arg2,arg3);
76125     } catch (std::out_of_range& e) {
76126       {
76127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76128       };
76129     } catch (std::exception& e) {
76130       {
76131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76132       };
76133     } catch (Dali::DaliException e) {
76134       {
76135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76136       };
76137     } catch (...) {
76138       {
76139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76140       };
76141     }
76142   }
76143
76144 }
76145
76146
76147 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleasedSwigExplicitItemFactory(void * jarg1, unsigned int jarg2, void * jarg3) {
76148   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
76149   unsigned int arg2 ;
76150   Dali::Actor arg3 ;
76151   Dali::Actor *argp3 ;
76152
76153   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
76154   arg2 = (unsigned int)jarg2;
76155   argp3 = (Dali::Actor *)jarg3;
76156   if (!argp3) {
76157     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76158     return ;
76159   }
76160   arg3 = *argp3;
76161   {
76162     try {
76163       (arg1)->Dali::Toolkit::ItemFactory::ItemReleased(arg2,arg3);
76164     } catch (std::out_of_range& e) {
76165       {
76166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76167       };
76168     } catch (std::exception& e) {
76169       {
76170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76171       };
76172     } catch (Dali::DaliException e) {
76173       {
76174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76175       };
76176     } catch (...) {
76177       {
76178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76179       };
76180     }
76181   }
76182
76183 }
76184
76185
76186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemFactory() {
76187   void * jresult ;
76188   Dali::Toolkit::ItemFactory *result = 0 ;
76189
76190   {
76191     try {
76192       result = (Dali::Toolkit::ItemFactory *)new SwigDirector_ItemFactory();
76193     } catch (std::out_of_range& e) {
76194       {
76195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76196       };
76197     } catch (std::exception& e) {
76198       {
76199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76200       };
76201     } catch (Dali::DaliException e) {
76202       {
76203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76204       };
76205     } catch (...) {
76206       {
76207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76208       };
76209     }
76210   }
76211
76212   jresult = (void *)result;
76213   return jresult;
76214 }
76215
76216
76217 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) {
76218   Dali::Toolkit::ItemFactory *obj = (Dali::Toolkit::ItemFactory *)objarg;
76219   SwigDirector_ItemFactory *director = dynamic_cast<SwigDirector_ItemFactory *>(obj);
76220   if (director) {
76221     director->swig_connect_director(callback0, callback1, callback2);
76222   }
76223 }
76224
76225
76226 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_SPEED_get() {
76227   int jresult ;
76228   int result;
76229
76230   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_SPEED;
76231   jresult = (int)result;
76232   return jresult;
76233 }
76234
76235
76236 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_DISTANCE_get() {
76237   int jresult ;
76238   int result;
76239
76240   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_DISTANCE;
76241   jresult = (int)result;
76242   return jresult;
76243 }
76244
76245
76246 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
76247   int jresult ;
76248   int result;
76249
76250   result = (int)Dali::Toolkit::ItemView::Property::WHEEL_SCROLL_DISTANCE_STEP;
76251   jresult = (int)result;
76252   return jresult;
76253 }
76254
76255
76256 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SNAP_TO_ITEM_ENABLED_get() {
76257   int jresult ;
76258   int result;
76259
76260   result = (int)Dali::Toolkit::ItemView::Property::SNAP_TO_ITEM_ENABLED;
76261   jresult = (int)result;
76262   return jresult;
76263 }
76264
76265
76266 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_REFRESH_INTERVAL_get() {
76267   int jresult ;
76268   int result;
76269
76270   result = (int)Dali::Toolkit::ItemView::Property::REFRESH_INTERVAL;
76271   jresult = (int)result;
76272   return jresult;
76273 }
76274
76275
76276 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_POSITION_get() {
76277   int jresult ;
76278   int result;
76279
76280   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_POSITION;
76281   jresult = (int)result;
76282   return jresult;
76283 }
76284
76285
76286 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_SPEED_get() {
76287   int jresult ;
76288   int result;
76289
76290   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_SPEED;
76291   jresult = (int)result;
76292   return jresult;
76293 }
76294
76295
76296 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_OVERSHOOT_get() {
76297   int jresult ;
76298   int result;
76299
76300   result = (int)Dali::Toolkit::ItemView::Property::OVERSHOOT;
76301   jresult = (int)result;
76302   return jresult;
76303 }
76304
76305
76306 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_DIRECTION_get() {
76307   int jresult ;
76308   int result;
76309
76310   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_DIRECTION;
76311   jresult = (int)result;
76312   return jresult;
76313 }
76314
76315
76316 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_ORIENTATION_get() {
76317   int jresult ;
76318   int result;
76319
76320   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_ORIENTATION;
76321   jresult = (int)result;
76322   return jresult;
76323 }
76324
76325
76326 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_CONTENT_SIZE_get() {
76327   int jresult ;
76328   int result;
76329
76330   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_CONTENT_SIZE;
76331   jresult = (int)result;
76332   return jresult;
76333 }
76334
76335
76336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView_Property() {
76337   void * jresult ;
76338   Dali::Toolkit::ItemView::Property *result = 0 ;
76339
76340   {
76341     try {
76342       result = (Dali::Toolkit::ItemView::Property *)new Dali::Toolkit::ItemView::Property();
76343     } catch (std::out_of_range& e) {
76344       {
76345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76346       };
76347     } catch (std::exception& e) {
76348       {
76349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76350       };
76351     } catch (Dali::DaliException e) {
76352       {
76353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76354       };
76355     } catch (...) {
76356       {
76357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76358       };
76359     }
76360   }
76361
76362   jresult = (void *)result;
76363   return jresult;
76364 }
76365
76366
76367 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView_Property(void * jarg1) {
76368   Dali::Toolkit::ItemView::Property *arg1 = (Dali::Toolkit::ItemView::Property *) 0 ;
76369
76370   arg1 = (Dali::Toolkit::ItemView::Property *)jarg1;
76371   {
76372     try {
76373       delete arg1;
76374     } catch (std::out_of_range& e) {
76375       {
76376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76377       };
76378     } catch (std::exception& e) {
76379       {
76380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76381       };
76382     } catch (Dali::DaliException e) {
76383       {
76384         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76385       };
76386     } catch (...) {
76387       {
76388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76389       };
76390     }
76391   }
76392
76393 }
76394
76395
76396 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_0() {
76397   void * jresult ;
76398   Dali::Toolkit::ItemView *result = 0 ;
76399
76400   {
76401     try {
76402       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView();
76403     } catch (std::out_of_range& e) {
76404       {
76405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76406       };
76407     } catch (std::exception& e) {
76408       {
76409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76410       };
76411     } catch (Dali::DaliException e) {
76412       {
76413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76414       };
76415     } catch (...) {
76416       {
76417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76418       };
76419     }
76420   }
76421
76422   jresult = (void *)result;
76423   return jresult;
76424 }
76425
76426
76427 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_1(void * jarg1) {
76428   void * jresult ;
76429   Dali::Toolkit::ItemView *arg1 = 0 ;
76430   Dali::Toolkit::ItemView *result = 0 ;
76431
76432   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76433   if (!arg1) {
76434     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
76435     return 0;
76436   }
76437   {
76438     try {
76439       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView((Dali::Toolkit::ItemView const &)*arg1);
76440     } catch (std::out_of_range& e) {
76441       {
76442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76443       };
76444     } catch (std::exception& e) {
76445       {
76446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76447       };
76448     } catch (Dali::DaliException e) {
76449       {
76450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76451       };
76452     } catch (...) {
76453       {
76454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76455       };
76456     }
76457   }
76458
76459   jresult = (void *)result;
76460   return jresult;
76461 }
76462
76463
76464 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_Assign(void * jarg1, void * jarg2) {
76465   void * jresult ;
76466   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76467   Dali::Toolkit::ItemView *arg2 = 0 ;
76468   Dali::Toolkit::ItemView *result = 0 ;
76469
76470   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76471   arg2 = (Dali::Toolkit::ItemView *)jarg2;
76472   if (!arg2) {
76473     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
76474     return 0;
76475   }
76476   {
76477     try {
76478       result = (Dali::Toolkit::ItemView *) &(arg1)->operator =((Dali::Toolkit::ItemView const &)*arg2);
76479     } catch (std::out_of_range& e) {
76480       {
76481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76482       };
76483     } catch (std::exception& e) {
76484       {
76485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76486       };
76487     } catch (Dali::DaliException e) {
76488       {
76489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76490       };
76491     } catch (...) {
76492       {
76493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76494       };
76495     }
76496   }
76497
76498   jresult = (void *)result;
76499   return jresult;
76500 }
76501
76502
76503 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView(void * jarg1) {
76504   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76505
76506   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76507   {
76508     try {
76509       delete arg1;
76510     } catch (std::out_of_range& e) {
76511       {
76512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76513       };
76514     } catch (std::exception& e) {
76515       {
76516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76517       };
76518     } catch (Dali::DaliException e) {
76519       {
76520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76521       };
76522     } catch (...) {
76523       {
76524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76525       };
76526     }
76527   }
76528
76529 }
76530
76531
76532 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_New(void * jarg1) {
76533   void * jresult ;
76534   Dali::Toolkit::ItemFactory *arg1 = 0 ;
76535   Dali::Toolkit::ItemView result;
76536
76537   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
76538   if (!arg1) {
76539     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemFactory & type is null", 0);
76540     return 0;
76541   }
76542   {
76543     try {
76544       result = Dali::Toolkit::ItemView::New(*arg1);
76545     } catch (std::out_of_range& e) {
76546       {
76547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76548       };
76549     } catch (std::exception& e) {
76550       {
76551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76552       };
76553     } catch (Dali::DaliException e) {
76554       {
76555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76556       };
76557     } catch (...) {
76558       {
76559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76560       };
76561     }
76562   }
76563
76564   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
76565   return jresult;
76566 }
76567
76568
76569 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_DownCast(void * jarg1) {
76570   void * jresult ;
76571   Dali::BaseHandle arg1 ;
76572   Dali::BaseHandle *argp1 ;
76573   Dali::Toolkit::ItemView result;
76574
76575   argp1 = (Dali::BaseHandle *)jarg1;
76576   if (!argp1) {
76577     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
76578     return 0;
76579   }
76580   arg1 = *argp1;
76581   {
76582     try {
76583       result = Dali::Toolkit::ItemView::DownCast(arg1);
76584     } catch (std::out_of_range& e) {
76585       {
76586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76587       };
76588     } catch (std::exception& e) {
76589       {
76590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76591       };
76592     } catch (Dali::DaliException e) {
76593       {
76594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76595       };
76596     } catch (...) {
76597       {
76598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76599       };
76600     }
76601   }
76602
76603   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
76604   return jresult;
76605 }
76606
76607
76608 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetLayoutCount(void * jarg1) {
76609   unsigned int jresult ;
76610   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76611   unsigned int result;
76612
76613   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76614   {
76615     try {
76616       result = (unsigned int)((Dali::Toolkit::ItemView const *)arg1)->GetLayoutCount();
76617     } catch (std::out_of_range& e) {
76618       {
76619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76620       };
76621     } catch (std::exception& e) {
76622       {
76623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76624       };
76625     } catch (Dali::DaliException e) {
76626       {
76627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76628       };
76629     } catch (...) {
76630       {
76631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76632       };
76633     }
76634   }
76635
76636   jresult = result;
76637   return jresult;
76638 }
76639
76640
76641 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_AddLayout(void * jarg1, void * jarg2) {
76642   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76643   Dali::Toolkit::ItemLayout *arg2 = 0 ;
76644
76645   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76646   arg2 = (Dali::Toolkit::ItemLayout *)jarg2;
76647   if (!arg2) {
76648     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemLayout & type is null", 0);
76649     return ;
76650   }
76651   {
76652     try {
76653       (arg1)->AddLayout(*arg2);
76654     } catch (std::out_of_range& e) {
76655       {
76656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76657       };
76658     } catch (std::exception& e) {
76659       {
76660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76661       };
76662     } catch (Dali::DaliException e) {
76663       {
76664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76665       };
76666     } catch (...) {
76667       {
76668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76669       };
76670     }
76671   }
76672
76673 }
76674
76675
76676 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveLayout(void * jarg1, unsigned int jarg2) {
76677   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76678   unsigned int arg2 ;
76679
76680   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76681   arg2 = (unsigned int)jarg2;
76682   {
76683     try {
76684       (arg1)->RemoveLayout(arg2);
76685     } catch (std::out_of_range& e) {
76686       {
76687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76688       };
76689     } catch (std::exception& e) {
76690       {
76691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76692       };
76693     } catch (Dali::DaliException e) {
76694       {
76695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76696       };
76697     } catch (...) {
76698       {
76699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76700       };
76701     }
76702   }
76703
76704 }
76705
76706
76707 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetLayout(void * jarg1, unsigned int jarg2) {
76708   void * jresult ;
76709   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76710   unsigned int arg2 ;
76711   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
76712
76713   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76714   arg2 = (unsigned int)jarg2;
76715   {
76716     try {
76717       result = ((Dali::Toolkit::ItemView const *)arg1)->GetLayout(arg2);
76718     } catch (std::out_of_range& e) {
76719       {
76720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76721       };
76722     } catch (std::exception& e) {
76723       {
76724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76725       };
76726     } catch (Dali::DaliException e) {
76727       {
76728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76729       };
76730     } catch (...) {
76731       {
76732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76733       };
76734     }
76735   }
76736
76737   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
76738   return jresult;
76739 }
76740
76741
76742 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetActiveLayout(void * jarg1) {
76743   void * jresult ;
76744   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76745   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
76746
76747   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76748   {
76749     try {
76750       result = ((Dali::Toolkit::ItemView const *)arg1)->GetActiveLayout();
76751     } catch (std::out_of_range& e) {
76752       {
76753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76754       };
76755     } catch (std::exception& e) {
76756       {
76757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76758       };
76759     } catch (Dali::DaliException e) {
76760       {
76761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76762       };
76763     } catch (...) {
76764       {
76765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76766       };
76767     }
76768   }
76769
76770   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
76771   return jresult;
76772 }
76773
76774
76775 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetCurrentLayoutPosition(void * jarg1, unsigned int jarg2) {
76776   float jresult ;
76777   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76778   Dali::Toolkit::ItemId arg2 ;
76779   float result;
76780
76781   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76782   arg2 = (Dali::Toolkit::ItemId)jarg2;
76783   {
76784     try {
76785       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetCurrentLayoutPosition(arg2);
76786     } catch (std::out_of_range& e) {
76787       {
76788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76789       };
76790     } catch (std::exception& e) {
76791       {
76792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76793       };
76794     } catch (Dali::DaliException e) {
76795       {
76796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76797       };
76798     } catch (...) {
76799       {
76800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76801       };
76802     }
76803   }
76804
76805   jresult = result;
76806   return jresult;
76807 }
76808
76809
76810 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ActivateLayout(void * jarg1, unsigned int jarg2, void * jarg3, float jarg4) {
76811   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76812   unsigned int arg2 ;
76813   Dali::Vector3 arg3 ;
76814   float arg4 ;
76815   Dali::Vector3 *argp3 ;
76816
76817   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76818   arg2 = (unsigned int)jarg2;
76819   argp3 = (Dali::Vector3 *)jarg3;
76820   if (!argp3) {
76821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
76822     return ;
76823   }
76824   arg3 = *argp3;
76825   arg4 = (float)jarg4;
76826   {
76827     try {
76828       (arg1)->ActivateLayout(arg2,arg3,arg4);
76829     } catch (std::out_of_range& e) {
76830       {
76831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76832       };
76833     } catch (std::exception& e) {
76834       {
76835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76836       };
76837     } catch (Dali::DaliException e) {
76838       {
76839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76840       };
76841     } catch (...) {
76842       {
76843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76844       };
76845     }
76846   }
76847
76848 }
76849
76850
76851 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_DeactivateCurrentLayout(void * jarg1) {
76852   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76853
76854   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76855   {
76856     try {
76857       (arg1)->DeactivateCurrentLayout();
76858     } catch (std::out_of_range& e) {
76859       {
76860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76861       };
76862     } catch (std::exception& e) {
76863       {
76864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76865       };
76866     } catch (Dali::DaliException e) {
76867       {
76868         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76869       };
76870     } catch (...) {
76871       {
76872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76873       };
76874     }
76875   }
76876
76877 }
76878
76879
76880 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeSpeed(void * jarg1, float jarg2) {
76881   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76882   float arg2 ;
76883
76884   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76885   arg2 = (float)jarg2;
76886   {
76887     try {
76888       (arg1)->SetMinimumSwipeSpeed(arg2);
76889     } catch (std::out_of_range& e) {
76890       {
76891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76892       };
76893     } catch (std::exception& e) {
76894       {
76895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76896       };
76897     } catch (Dali::DaliException e) {
76898       {
76899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76900       };
76901     } catch (...) {
76902       {
76903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76904       };
76905     }
76906   }
76907
76908 }
76909
76910
76911 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeSpeed(void * jarg1) {
76912   float jresult ;
76913   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76914   float result;
76915
76916   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76917   {
76918     try {
76919       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeSpeed();
76920     } catch (std::out_of_range& e) {
76921       {
76922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76923       };
76924     } catch (std::exception& e) {
76925       {
76926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76927       };
76928     } catch (Dali::DaliException e) {
76929       {
76930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76931       };
76932     } catch (...) {
76933       {
76934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76935       };
76936     }
76937   }
76938
76939   jresult = result;
76940   return jresult;
76941 }
76942
76943
76944 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeDistance(void * jarg1, float jarg2) {
76945   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76946   float arg2 ;
76947
76948   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76949   arg2 = (float)jarg2;
76950   {
76951     try {
76952       (arg1)->SetMinimumSwipeDistance(arg2);
76953     } catch (std::out_of_range& e) {
76954       {
76955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76956       };
76957     } catch (std::exception& e) {
76958       {
76959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76960       };
76961     } catch (Dali::DaliException e) {
76962       {
76963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76964       };
76965     } catch (...) {
76966       {
76967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76968       };
76969     }
76970   }
76971
76972 }
76973
76974
76975 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeDistance(void * jarg1) {
76976   float jresult ;
76977   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76978   float result;
76979
76980   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76981   {
76982     try {
76983       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeDistance();
76984     } catch (std::out_of_range& e) {
76985       {
76986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76987       };
76988     } catch (std::exception& e) {
76989       {
76990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76991       };
76992     } catch (Dali::DaliException e) {
76993       {
76994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76995       };
76996     } catch (...) {
76997       {
76998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76999       };
77000     }
77001   }
77002
77003   jresult = result;
77004   return jresult;
77005 }
77006
77007
77008 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetWheelScrollDistanceStep(void * jarg1, float jarg2) {
77009   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77010   float arg2 ;
77011
77012   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77013   arg2 = (float)jarg2;
77014   {
77015     try {
77016       (arg1)->SetWheelScrollDistanceStep(arg2);
77017     } catch (std::out_of_range& e) {
77018       {
77019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77020       };
77021     } catch (std::exception& e) {
77022       {
77023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77024       };
77025     } catch (Dali::DaliException e) {
77026       {
77027         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77028       };
77029     } catch (...) {
77030       {
77031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77032       };
77033     }
77034   }
77035
77036 }
77037
77038
77039 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetWheelScrollDistanceStep(void * jarg1) {
77040   float jresult ;
77041   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77042   float result;
77043
77044   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77045   {
77046     try {
77047       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetWheelScrollDistanceStep();
77048     } catch (std::out_of_range& e) {
77049       {
77050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77051       };
77052     } catch (std::exception& e) {
77053       {
77054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77055       };
77056     } catch (Dali::DaliException e) {
77057       {
77058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77059       };
77060     } catch (...) {
77061       {
77062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77063       };
77064     }
77065   }
77066
77067   jresult = result;
77068   return jresult;
77069 }
77070
77071
77072 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoring(void * jarg1, unsigned int jarg2) {
77073   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77074   bool arg2 ;
77075
77076   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77077   arg2 = jarg2 ? true : false;
77078   {
77079     try {
77080       (arg1)->SetAnchoring(arg2);
77081     } catch (std::out_of_range& e) {
77082       {
77083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77084       };
77085     } catch (std::exception& e) {
77086       {
77087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77088       };
77089     } catch (Dali::DaliException e) {
77090       {
77091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77092       };
77093     } catch (...) {
77094       {
77095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77096       };
77097     }
77098   }
77099
77100 }
77101
77102 //// ========================= end of part 3 =============================
77103
77104 //// ========================== start part 4 ===============================
77105
77106
77107 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoring(void * jarg1) {
77108   unsigned int jresult ;
77109   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77110   bool result;
77111
77112   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77113   {
77114     try {
77115       result = (bool)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoring();
77116     } catch (std::out_of_range& e) {
77117       {
77118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77119       };
77120     } catch (std::exception& e) {
77121       {
77122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77123       };
77124     } catch (Dali::DaliException e) {
77125       {
77126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77127       };
77128     } catch (...) {
77129       {
77130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77131       };
77132     }
77133   }
77134
77135   jresult = result;
77136   return jresult;
77137 }
77138
77139
77140 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoringDuration(void * jarg1, float jarg2) {
77141   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77142   float arg2 ;
77143
77144   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77145   arg2 = (float)jarg2;
77146   {
77147     try {
77148       (arg1)->SetAnchoringDuration(arg2);
77149     } catch (std::out_of_range& e) {
77150       {
77151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77152       };
77153     } catch (std::exception& e) {
77154       {
77155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77156       };
77157     } catch (Dali::DaliException e) {
77158       {
77159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77160       };
77161     } catch (...) {
77162       {
77163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77164       };
77165     }
77166   }
77167
77168 }
77169
77170
77171 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoringDuration(void * jarg1) {
77172   float jresult ;
77173   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77174   float result;
77175
77176   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77177   {
77178     try {
77179       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoringDuration();
77180     } catch (std::out_of_range& e) {
77181       {
77182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77183       };
77184     } catch (std::exception& e) {
77185       {
77186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77187       };
77188     } catch (Dali::DaliException e) {
77189       {
77190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77191       };
77192     } catch (...) {
77193       {
77194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77195       };
77196     }
77197   }
77198
77199   jresult = result;
77200   return jresult;
77201 }
77202
77203
77204 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ScrollToItem(void * jarg1, unsigned int jarg2, float jarg3) {
77205   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77206   Dali::Toolkit::ItemId arg2 ;
77207   float arg3 ;
77208
77209   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77210   arg2 = (Dali::Toolkit::ItemId)jarg2;
77211   arg3 = (float)jarg3;
77212   {
77213     try {
77214       (arg1)->ScrollToItem(arg2,arg3);
77215     } catch (std::out_of_range& e) {
77216       {
77217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77218       };
77219     } catch (std::exception& e) {
77220       {
77221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77222       };
77223     } catch (Dali::DaliException e) {
77224       {
77225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77226       };
77227     } catch (...) {
77228       {
77229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77230       };
77231     }
77232   }
77233
77234 }
77235
77236
77237 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetRefreshInterval(void * jarg1, float jarg2) {
77238   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77239   float arg2 ;
77240
77241   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77242   arg2 = (float)jarg2;
77243   {
77244     try {
77245       (arg1)->SetRefreshInterval(arg2);
77246     } catch (std::out_of_range& e) {
77247       {
77248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77249       };
77250     } catch (std::exception& e) {
77251       {
77252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77253       };
77254     } catch (Dali::DaliException e) {
77255       {
77256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77257       };
77258     } catch (...) {
77259       {
77260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77261       };
77262     }
77263   }
77264
77265 }
77266
77267
77268 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetRefreshInterval(void * jarg1) {
77269   float jresult ;
77270   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77271   float result;
77272
77273   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77274   {
77275     try {
77276       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetRefreshInterval();
77277     } catch (std::out_of_range& e) {
77278       {
77279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77280       };
77281     } catch (std::exception& e) {
77282       {
77283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77284       };
77285     } catch (Dali::DaliException e) {
77286       {
77287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77288       };
77289     } catch (...) {
77290       {
77291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77292       };
77293     }
77294   }
77295
77296   jresult = result;
77297   return jresult;
77298 }
77299
77300
77301 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_Refresh(void * jarg1) {
77302   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77303
77304   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77305   {
77306     try {
77307       (arg1)->Refresh();
77308     } catch (std::out_of_range& e) {
77309       {
77310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77311       };
77312     } catch (std::exception& e) {
77313       {
77314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77315       };
77316     } catch (Dali::DaliException e) {
77317       {
77318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77319       };
77320     } catch (...) {
77321       {
77322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77323       };
77324     }
77325   }
77326
77327 }
77328
77329
77330 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItem(void * jarg1, unsigned int jarg2) {
77331   void * jresult ;
77332   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77333   Dali::Toolkit::ItemId arg2 ;
77334   Dali::Actor result;
77335
77336   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77337   arg2 = (Dali::Toolkit::ItemId)jarg2;
77338   {
77339     try {
77340       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItem(arg2);
77341     } catch (std::out_of_range& e) {
77342       {
77343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77344       };
77345     } catch (std::exception& e) {
77346       {
77347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77348       };
77349     } catch (Dali::DaliException e) {
77350       {
77351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77352       };
77353     } catch (...) {
77354       {
77355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77356       };
77357     }
77358   }
77359
77360   jresult = new Dali::Actor((const Dali::Actor &)result);
77361   return jresult;
77362 }
77363
77364
77365 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetItemId(void * jarg1, void * jarg2) {
77366   unsigned int jresult ;
77367   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77368   Dali::Actor arg2 ;
77369   Dali::Actor *argp2 ;
77370   Dali::Toolkit::ItemId result;
77371
77372   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77373   argp2 = (Dali::Actor *)jarg2;
77374   if (!argp2) {
77375     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
77376     return 0;
77377   }
77378   arg2 = *argp2;
77379   {
77380     try {
77381       result = (Dali::Toolkit::ItemId)((Dali::Toolkit::ItemView const *)arg1)->GetItemId(arg2);
77382     } catch (std::out_of_range& e) {
77383       {
77384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77385       };
77386     } catch (std::exception& e) {
77387       {
77388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77389       };
77390     } catch (Dali::DaliException e) {
77391       {
77392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77393       };
77394     } catch (...) {
77395       {
77396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77397       };
77398     }
77399   }
77400
77401   jresult = result;
77402   return jresult;
77403 }
77404
77405
77406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItem(void * jarg1, void * jarg2, float jarg3) {
77407   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77408   Dali::Toolkit::Item arg2 ;
77409   float arg3 ;
77410   Dali::Toolkit::Item *argp2 ;
77411
77412   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77413   argp2 = (Dali::Toolkit::Item *)jarg2;
77414   if (!argp2) {
77415     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
77416     return ;
77417   }
77418   arg2 = *argp2;
77419   arg3 = (float)jarg3;
77420   {
77421     try {
77422       (arg1)->InsertItem(arg2,arg3);
77423     } catch (std::out_of_range& e) {
77424       {
77425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77426       };
77427     } catch (std::exception& e) {
77428       {
77429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77430       };
77431     } catch (Dali::DaliException e) {
77432       {
77433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77434       };
77435     } catch (...) {
77436       {
77437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77438       };
77439     }
77440   }
77441
77442 }
77443
77444
77445 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItems(void * jarg1, void * jarg2, float jarg3) {
77446   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77447   Dali::Toolkit::ItemContainer *arg2 = 0 ;
77448   float arg3 ;
77449
77450   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77451   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
77452   if (!arg2) {
77453     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
77454     return ;
77455   }
77456   arg3 = (float)jarg3;
77457   {
77458     try {
77459       (arg1)->InsertItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
77460     } catch (std::out_of_range& e) {
77461       {
77462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77463       };
77464     } catch (std::exception& e) {
77465       {
77466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77467       };
77468     } catch (Dali::DaliException e) {
77469       {
77470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77471       };
77472     } catch (...) {
77473       {
77474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77475       };
77476     }
77477   }
77478
77479 }
77480
77481
77482 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItem(void * jarg1, unsigned int jarg2, float jarg3) {
77483   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77484   Dali::Toolkit::ItemId arg2 ;
77485   float arg3 ;
77486
77487   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77488   arg2 = (Dali::Toolkit::ItemId)jarg2;
77489   arg3 = (float)jarg3;
77490   {
77491     try {
77492       (arg1)->RemoveItem(arg2,arg3);
77493     } catch (std::out_of_range& e) {
77494       {
77495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77496       };
77497     } catch (std::exception& e) {
77498       {
77499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77500       };
77501     } catch (Dali::DaliException e) {
77502       {
77503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77504       };
77505     } catch (...) {
77506       {
77507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77508       };
77509     }
77510   }
77511
77512 }
77513
77514
77515 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItems(void * jarg1, void * jarg2, float jarg3) {
77516   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77517   Dali::Toolkit::ItemIdContainer *arg2 = 0 ;
77518   float arg3 ;
77519
77520   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77521   arg2 = (Dali::Toolkit::ItemIdContainer *)jarg2;
77522   if (!arg2) {
77523     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemIdContainer const & type is null", 0);
77524     return ;
77525   }
77526   arg3 = (float)jarg3;
77527   {
77528     try {
77529       (arg1)->RemoveItems((Dali::Toolkit::ItemIdContainer const &)*arg2,arg3);
77530     } catch (std::out_of_range& e) {
77531       {
77532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77533       };
77534     } catch (std::exception& e) {
77535       {
77536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77537       };
77538     } catch (Dali::DaliException e) {
77539       {
77540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77541       };
77542     } catch (...) {
77543       {
77544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77545       };
77546     }
77547   }
77548
77549 }
77550
77551
77552 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItem(void * jarg1, void * jarg2, float jarg3) {
77553   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77554   Dali::Toolkit::Item arg2 ;
77555   float arg3 ;
77556   Dali::Toolkit::Item *argp2 ;
77557
77558   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77559   argp2 = (Dali::Toolkit::Item *)jarg2;
77560   if (!argp2) {
77561     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
77562     return ;
77563   }
77564   arg2 = *argp2;
77565   arg3 = (float)jarg3;
77566   {
77567     try {
77568       (arg1)->ReplaceItem(arg2,arg3);
77569     } catch (std::out_of_range& e) {
77570       {
77571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77572       };
77573     } catch (std::exception& e) {
77574       {
77575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77576       };
77577     } catch (Dali::DaliException e) {
77578       {
77579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77580       };
77581     } catch (...) {
77582       {
77583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77584       };
77585     }
77586   }
77587
77588 }
77589
77590
77591 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItems(void * jarg1, void * jarg2, float jarg3) {
77592   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77593   Dali::Toolkit::ItemContainer *arg2 = 0 ;
77594   float arg3 ;
77595
77596   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77597   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
77598   if (!arg2) {
77599     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
77600     return ;
77601   }
77602   arg3 = (float)jarg3;
77603   {
77604     try {
77605       (arg1)->ReplaceItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
77606     } catch (std::out_of_range& e) {
77607       {
77608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77609       };
77610     } catch (std::exception& e) {
77611       {
77612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77613       };
77614     } catch (Dali::DaliException e) {
77615       {
77616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77617       };
77618     } catch (...) {
77619       {
77620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77621       };
77622     }
77623   }
77624
77625 }
77626
77627
77628 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsParentOrigin(void * jarg1, void * jarg2) {
77629   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77630   Dali::Vector3 *arg2 = 0 ;
77631
77632   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77633   arg2 = (Dali::Vector3 *)jarg2;
77634   if (!arg2) {
77635     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
77636     return ;
77637   }
77638   {
77639     try {
77640       (arg1)->SetItemsParentOrigin((Dali::Vector3 const &)*arg2);
77641     } catch (std::out_of_range& e) {
77642       {
77643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77644       };
77645     } catch (std::exception& e) {
77646       {
77647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77648       };
77649     } catch (Dali::DaliException e) {
77650       {
77651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77652       };
77653     } catch (...) {
77654       {
77655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77656       };
77657     }
77658   }
77659
77660 }
77661
77662
77663 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsParentOrigin(void * jarg1) {
77664   void * jresult ;
77665   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77666   Dali::Vector3 result;
77667
77668   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77669   {
77670     try {
77671       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsParentOrigin();
77672     } catch (std::out_of_range& e) {
77673       {
77674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77675       };
77676     } catch (std::exception& e) {
77677       {
77678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77679       };
77680     } catch (Dali::DaliException e) {
77681       {
77682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77683       };
77684     } catch (...) {
77685       {
77686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77687       };
77688     }
77689   }
77690
77691   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
77692   return jresult;
77693 }
77694
77695
77696 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsAnchorPoint(void * jarg1, void * jarg2) {
77697   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77698   Dali::Vector3 *arg2 = 0 ;
77699
77700   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77701   arg2 = (Dali::Vector3 *)jarg2;
77702   if (!arg2) {
77703     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
77704     return ;
77705   }
77706   {
77707     try {
77708       (arg1)->SetItemsAnchorPoint((Dali::Vector3 const &)*arg2);
77709     } catch (std::out_of_range& e) {
77710       {
77711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77712       };
77713     } catch (std::exception& e) {
77714       {
77715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77716       };
77717     } catch (Dali::DaliException e) {
77718       {
77719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77720       };
77721     } catch (...) {
77722       {
77723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77724       };
77725     }
77726   }
77727
77728 }
77729
77730
77731 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsAnchorPoint(void * jarg1) {
77732   void * jresult ;
77733   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77734   Dali::Vector3 result;
77735
77736   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77737   {
77738     try {
77739       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsAnchorPoint();
77740     } catch (std::out_of_range& e) {
77741       {
77742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77743       };
77744     } catch (std::exception& e) {
77745       {
77746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77747       };
77748     } catch (Dali::DaliException e) {
77749       {
77750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77751       };
77752     } catch (...) {
77753       {
77754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77755       };
77756     }
77757   }
77758
77759   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
77760   return jresult;
77761 }
77762
77763
77764 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_GetItemsRange(void * jarg1, void * jarg2) {
77765   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77766   Dali::Toolkit::ItemRange *arg2 = 0 ;
77767
77768   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77769   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
77770   if (!arg2) {
77771     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange & type is null", 0);
77772     return ;
77773   }
77774   {
77775     try {
77776       (arg1)->GetItemsRange(*arg2);
77777     } catch (std::out_of_range& e) {
77778       {
77779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77780       };
77781     } catch (std::exception& e) {
77782       {
77783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77784       };
77785     } catch (Dali::DaliException e) {
77786       {
77787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77788       };
77789     } catch (...) {
77790       {
77791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77792       };
77793     }
77794   }
77795
77796 }
77797
77798
77799 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_LayoutActivatedSignal(void * jarg1) {
77800   void * jresult ;
77801   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77802   Dali::Toolkit::ItemView::LayoutActivatedSignalType *result = 0 ;
77803
77804   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77805   {
77806     try {
77807       result = (Dali::Toolkit::ItemView::LayoutActivatedSignalType *) &(arg1)->LayoutActivatedSignal();
77808     } catch (std::out_of_range& e) {
77809       {
77810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77811       };
77812     } catch (std::exception& e) {
77813       {
77814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77815       };
77816     } catch (Dali::DaliException e) {
77817       {
77818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77819       };
77820     } catch (...) {
77821       {
77822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77823       };
77824     }
77825   }
77826
77827   jresult = (void *)result;
77828   return jresult;
77829 }
77830
77831
77832 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MoveActorConstraint(void * jarg1, void * jarg2) {
77833   Dali::Vector3 *arg1 = 0 ;
77834   PropertyInputContainer *arg2 = 0 ;
77835
77836   arg1 = (Dali::Vector3 *)jarg1;
77837   if (!arg1) {
77838     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
77839     return ;
77840   }
77841   arg2 = (PropertyInputContainer *)jarg2;
77842   if (!arg2) {
77843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
77844     return ;
77845   }
77846   {
77847     try {
77848       Dali::Toolkit::MoveActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
77849     } catch (std::out_of_range& e) {
77850       {
77851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77852       };
77853     } catch (std::exception& e) {
77854       {
77855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77856       };
77857     } catch (Dali::DaliException e) {
77858       {
77859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77860       };
77861     } catch (...) {
77862       {
77863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77864       };
77865     }
77866   }
77867
77868 }
77869
77870
77871 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WrapActorConstraint(void * jarg1, void * jarg2) {
77872   Dali::Vector3 *arg1 = 0 ;
77873   PropertyInputContainer *arg2 = 0 ;
77874
77875   arg1 = (Dali::Vector3 *)jarg1;
77876   if (!arg1) {
77877     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
77878     return ;
77879   }
77880   arg2 = (PropertyInputContainer *)jarg2;
77881   if (!arg2) {
77882     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
77883     return ;
77884   }
77885   {
77886     try {
77887       Dali::Toolkit::WrapActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
77888     } catch (std::out_of_range& e) {
77889       {
77890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77891       };
77892     } catch (std::exception& e) {
77893       {
77894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77895       };
77896     } catch (Dali::DaliException e) {
77897       {
77898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77899       };
77900     } catch (...) {
77901       {
77902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77903       };
77904     }
77905   }
77906
77907 }
77908
77909
77910 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewEffect() {
77911   void * jresult ;
77912   Dali::Toolkit::ScrollViewEffect *result = 0 ;
77913
77914   {
77915     try {
77916       result = (Dali::Toolkit::ScrollViewEffect *)new Dali::Toolkit::ScrollViewEffect();
77917     } catch (std::out_of_range& e) {
77918       {
77919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77920       };
77921     } catch (std::exception& e) {
77922       {
77923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77924       };
77925     } catch (Dali::DaliException e) {
77926       {
77927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77928       };
77929     } catch (...) {
77930       {
77931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77932       };
77933     }
77934   }
77935
77936   jresult = (void *)result;
77937   return jresult;
77938 }
77939
77940
77941 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewEffect(void * jarg1) {
77942   Dali::Toolkit::ScrollViewEffect *arg1 = (Dali::Toolkit::ScrollViewEffect *) 0 ;
77943
77944   arg1 = (Dali::Toolkit::ScrollViewEffect *)jarg1;
77945   {
77946     try {
77947       delete arg1;
77948     } catch (std::out_of_range& e) {
77949       {
77950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77951       };
77952     } catch (std::exception& e) {
77953       {
77954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77955       };
77956     } catch (Dali::DaliException e) {
77957       {
77958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77959       };
77960     } catch (...) {
77961       {
77962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77963       };
77964     }
77965   }
77966
77967 }
77968
77969
77970 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_New(void * jarg1, void * jarg2, int jarg3, void * jarg4, unsigned int jarg5) {
77971   void * jresult ;
77972   Dali::Path arg1 ;
77973   Dali::Vector3 *arg2 = 0 ;
77974   Dali::Property::Index arg3 ;
77975   Dali::Vector3 *arg4 = 0 ;
77976   unsigned int arg5 ;
77977   Dali::Path *argp1 ;
77978   Dali::Toolkit::ScrollViewPagePathEffect result;
77979
77980   argp1 = (Dali::Path *)jarg1;
77981   if (!argp1) {
77982     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
77983     return 0;
77984   }
77985   arg1 = *argp1;
77986   arg2 = (Dali::Vector3 *)jarg2;
77987   if (!arg2) {
77988     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
77989     return 0;
77990   }
77991   arg3 = (Dali::Property::Index)jarg3;
77992   arg4 = (Dali::Vector3 *)jarg4;
77993   if (!arg4) {
77994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
77995     return 0;
77996   }
77997   arg5 = (unsigned int)jarg5;
77998   {
77999     try {
78000       result = Dali::Toolkit::ScrollViewPagePathEffect::New(arg1,(Dali::Vector3 const &)*arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
78001     } catch (std::out_of_range& e) {
78002       {
78003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78004       };
78005     } catch (std::exception& e) {
78006       {
78007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78008       };
78009     } catch (Dali::DaliException e) {
78010       {
78011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78012       };
78013     } catch (...) {
78014       {
78015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78016       };
78017     }
78018   }
78019
78020   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
78021   return jresult;
78022 }
78023
78024
78025 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewPagePathEffect() {
78026   void * jresult ;
78027   Dali::Toolkit::ScrollViewPagePathEffect *result = 0 ;
78028
78029   {
78030     try {
78031       result = (Dali::Toolkit::ScrollViewPagePathEffect *)new Dali::Toolkit::ScrollViewPagePathEffect();
78032     } catch (std::out_of_range& e) {
78033       {
78034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78035       };
78036     } catch (std::exception& e) {
78037       {
78038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78039       };
78040     } catch (Dali::DaliException e) {
78041       {
78042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78043       };
78044     } catch (...) {
78045       {
78046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78047       };
78048     }
78049   }
78050
78051   jresult = (void *)result;
78052   return jresult;
78053 }
78054
78055
78056 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_DownCast(void * jarg1) {
78057   void * jresult ;
78058   Dali::BaseHandle arg1 ;
78059   Dali::BaseHandle *argp1 ;
78060   Dali::Toolkit::ScrollViewPagePathEffect result;
78061
78062   argp1 = (Dali::BaseHandle *)jarg1;
78063   if (!argp1) {
78064     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
78065     return 0;
78066   }
78067   arg1 = *argp1;
78068   {
78069     try {
78070       result = Dali::Toolkit::ScrollViewPagePathEffect::DownCast(arg1);
78071     } catch (std::out_of_range& e) {
78072       {
78073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78074       };
78075     } catch (std::exception& e) {
78076       {
78077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78078       };
78079     } catch (Dali::DaliException e) {
78080       {
78081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78082       };
78083     } catch (...) {
78084       {
78085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78086       };
78087     }
78088   }
78089
78090   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
78091   return jresult;
78092 }
78093
78094
78095 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_ApplyToPage(void * jarg1, void * jarg2, unsigned int jarg3) {
78096   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
78097   Dali::Actor arg2 ;
78098   unsigned int arg3 ;
78099   Dali::Actor *argp2 ;
78100
78101   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
78102   argp2 = (Dali::Actor *)jarg2;
78103   if (!argp2) {
78104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
78105     return ;
78106   }
78107   arg2 = *argp2;
78108   arg3 = (unsigned int)jarg3;
78109   {
78110     try {
78111       (arg1)->ApplyToPage(arg2,arg3);
78112     } catch (std::out_of_range& e) {
78113       {
78114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78115       };
78116     } catch (std::exception& e) {
78117       {
78118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78119       };
78120     } catch (Dali::DaliException e) {
78121       {
78122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78123       };
78124     } catch (...) {
78125       {
78126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78127       };
78128     }
78129   }
78130
78131 }
78132
78133
78134 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewPagePathEffect(void * jarg1) {
78135   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
78136
78137   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
78138   {
78139     try {
78140       delete arg1;
78141     } catch (std::out_of_range& e) {
78142       {
78143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78144       };
78145     } catch (std::exception& e) {
78146       {
78147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78148       };
78149     } catch (Dali::DaliException e) {
78150       {
78151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78152       };
78153     } catch (...) {
78154       {
78155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78156       };
78157     }
78158   }
78159
78160 }
78161
78162
78163 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_x_set(void * jarg1, int jarg2) {
78164   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
78165   Dali::Toolkit::ClampState arg2 ;
78166
78167   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
78168   arg2 = (Dali::Toolkit::ClampState)jarg2;
78169   if (arg1) (arg1)->x = arg2;
78170 }
78171
78172
78173 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_x_get(void * jarg1) {
78174   int jresult ;
78175   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
78176   Dali::Toolkit::ClampState result;
78177
78178   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
78179   result = (Dali::Toolkit::ClampState) ((arg1)->x);
78180   jresult = (int)result;
78181   return jresult;
78182 }
78183
78184
78185 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_y_set(void * jarg1, int jarg2) {
78186   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
78187   Dali::Toolkit::ClampState arg2 ;
78188
78189   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
78190   arg2 = (Dali::Toolkit::ClampState)jarg2;
78191   if (arg1) (arg1)->y = arg2;
78192 }
78193
78194
78195 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_y_get(void * jarg1) {
78196   int jresult ;
78197   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
78198   Dali::Toolkit::ClampState result;
78199
78200   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
78201   result = (Dali::Toolkit::ClampState) ((arg1)->y);
78202   jresult = (int)result;
78203   return jresult;
78204 }
78205
78206
78207 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ClampState2D() {
78208   void * jresult ;
78209   Dali::Toolkit::ClampState2D *result = 0 ;
78210
78211   {
78212     try {
78213       result = (Dali::Toolkit::ClampState2D *)new Dali::Toolkit::ClampState2D();
78214     } catch (std::out_of_range& e) {
78215       {
78216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78217       };
78218     } catch (std::exception& e) {
78219       {
78220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78221       };
78222     } catch (Dali::DaliException e) {
78223       {
78224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78225       };
78226     } catch (...) {
78227       {
78228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78229       };
78230     }
78231   }
78232
78233   jresult = (void *)result;
78234   return jresult;
78235 }
78236
78237
78238 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ClampState2D(void * jarg1) {
78239   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
78240
78241   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
78242   {
78243     try {
78244       delete arg1;
78245     } catch (std::out_of_range& e) {
78246       {
78247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78248       };
78249     } catch (std::exception& e) {
78250       {
78251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78252       };
78253     } catch (Dali::DaliException e) {
78254       {
78255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78256       };
78257     } catch (...) {
78258       {
78259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78260       };
78261     }
78262   }
78263
78264 }
78265
78266
78267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_0(float jarg1, float jarg2, unsigned int jarg3) {
78268   void * jresult ;
78269   float arg1 ;
78270   float arg2 ;
78271   bool arg3 ;
78272   Dali::Toolkit::RulerDomain *result = 0 ;
78273
78274   arg1 = (float)jarg1;
78275   arg2 = (float)jarg2;
78276   arg3 = jarg3 ? true : false;
78277   {
78278     try {
78279       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2,arg3);
78280     } catch (std::out_of_range& e) {
78281       {
78282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78283       };
78284     } catch (std::exception& e) {
78285       {
78286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78287       };
78288     } catch (Dali::DaliException e) {
78289       {
78290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78291       };
78292     } catch (...) {
78293       {
78294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78295       };
78296     }
78297   }
78298
78299   jresult = (void *)result;
78300   return jresult;
78301 }
78302
78303
78304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_1(float jarg1, float jarg2) {
78305   void * jresult ;
78306   float arg1 ;
78307   float arg2 ;
78308   Dali::Toolkit::RulerDomain *result = 0 ;
78309
78310   arg1 = (float)jarg1;
78311   arg2 = (float)jarg2;
78312   {
78313     try {
78314       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2);
78315     } catch (std::out_of_range& e) {
78316       {
78317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78318       };
78319     } catch (std::exception& e) {
78320       {
78321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78322       };
78323     } catch (Dali::DaliException e) {
78324       {
78325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78326       };
78327     } catch (...) {
78328       {
78329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78330       };
78331     }
78332   }
78333
78334   jresult = (void *)result;
78335   return jresult;
78336 }
78337
78338
78339 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_min_set(void * jarg1, float jarg2) {
78340   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78341   float arg2 ;
78342
78343   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78344   arg2 = (float)jarg2;
78345   if (arg1) (arg1)->min = arg2;
78346 }
78347
78348
78349 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_min_get(void * jarg1) {
78350   float jresult ;
78351   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78352   float result;
78353
78354   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78355   result = (float) ((arg1)->min);
78356   jresult = result;
78357   return jresult;
78358 }
78359
78360
78361 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_max_set(void * jarg1, float jarg2) {
78362   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78363   float arg2 ;
78364
78365   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78366   arg2 = (float)jarg2;
78367   if (arg1) (arg1)->max = arg2;
78368 }
78369
78370
78371 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_max_get(void * jarg1) {
78372   float jresult ;
78373   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78374   float result;
78375
78376   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78377   result = (float) ((arg1)->max);
78378   jresult = result;
78379   return jresult;
78380 }
78381
78382
78383 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_set(void * jarg1, unsigned int jarg2) {
78384   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78385   bool arg2 ;
78386
78387   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78388   arg2 = jarg2 ? true : false;
78389   if (arg1) (arg1)->enabled = arg2;
78390 }
78391
78392
78393 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_get(void * jarg1) {
78394   unsigned int jresult ;
78395   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78396   bool result;
78397
78398   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78399   result = (bool) ((arg1)->enabled);
78400   jresult = result;
78401   return jresult;
78402 }
78403
78404
78405 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
78406   float jresult ;
78407   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78408   float arg2 ;
78409   float arg3 ;
78410   float arg4 ;
78411   float result;
78412
78413   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78414   arg2 = (float)jarg2;
78415   arg3 = (float)jarg3;
78416   arg4 = (float)jarg4;
78417   {
78418     try {
78419       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4);
78420     } catch (std::out_of_range& e) {
78421       {
78422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78423       };
78424     } catch (std::exception& e) {
78425       {
78426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78427       };
78428     } catch (Dali::DaliException e) {
78429       {
78430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78431       };
78432     } catch (...) {
78433       {
78434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78435       };
78436     }
78437   }
78438
78439   jresult = result;
78440   return jresult;
78441 }
78442
78443
78444 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
78445   float jresult ;
78446   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78447   float arg2 ;
78448   float arg3 ;
78449   float result;
78450
78451   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78452   arg2 = (float)jarg2;
78453   arg3 = (float)jarg3;
78454   {
78455     try {
78456       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3);
78457     } catch (std::out_of_range& e) {
78458       {
78459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78460       };
78461     } catch (std::exception& e) {
78462       {
78463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78464       };
78465     } catch (Dali::DaliException e) {
78466       {
78467         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78468       };
78469     } catch (...) {
78470       {
78471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78472       };
78473     }
78474   }
78475
78476   jresult = result;
78477   return jresult;
78478 }
78479
78480
78481 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_2(void * jarg1, float jarg2) {
78482   float jresult ;
78483   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78484   float arg2 ;
78485   float result;
78486
78487   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78488   arg2 = (float)jarg2;
78489   {
78490     try {
78491       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2);
78492     } catch (std::out_of_range& e) {
78493       {
78494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78495       };
78496     } catch (std::exception& e) {
78497       {
78498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78499       };
78500     } catch (Dali::DaliException e) {
78501       {
78502         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78503       };
78504     } catch (...) {
78505       {
78506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78507       };
78508     }
78509   }
78510
78511   jresult = result;
78512   return jresult;
78513 }
78514
78515
78516 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
78517   float jresult ;
78518   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78519   float arg2 ;
78520   float arg3 ;
78521   float arg4 ;
78522   Dali::Toolkit::ClampState *arg5 = 0 ;
78523   float result;
78524
78525   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78526   arg2 = (float)jarg2;
78527   arg3 = (float)jarg3;
78528   arg4 = (float)jarg4;
78529   arg5 = (Dali::Toolkit::ClampState *)jarg5;
78530   if (!arg5) {
78531     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
78532     return 0;
78533   }
78534   {
78535     try {
78536       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
78537     } catch (std::out_of_range& e) {
78538       {
78539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78540       };
78541     } catch (std::exception& e) {
78542       {
78543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78544       };
78545     } catch (Dali::DaliException e) {
78546       {
78547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78548       };
78549     } catch (...) {
78550       {
78551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78552       };
78553     }
78554   }
78555
78556   jresult = result;
78557   return jresult;
78558 }
78559
78560
78561 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_GetSize(void * jarg1) {
78562   float jresult ;
78563   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78564   float result;
78565
78566   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78567   {
78568     try {
78569       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->GetSize();
78570     } catch (std::out_of_range& e) {
78571       {
78572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78573       };
78574     } catch (std::exception& e) {
78575       {
78576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78577       };
78578     } catch (Dali::DaliException e) {
78579       {
78580         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78581       };
78582     } catch (...) {
78583       {
78584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78585       };
78586     }
78587   }
78588
78589   jresult = result;
78590   return jresult;
78591 }
78592
78593
78594 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerDomain(void * jarg1) {
78595   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78596
78597   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78598   {
78599     try {
78600       delete arg1;
78601     } catch (std::out_of_range& e) {
78602       {
78603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78604       };
78605     } catch (std::exception& e) {
78606       {
78607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78608       };
78609     } catch (Dali::DaliException e) {
78610       {
78611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78612       };
78613     } catch (...) {
78614       {
78615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78616       };
78617     }
78618   }
78619
78620 }
78621
78622
78623 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
78624   float jresult ;
78625   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78626   float arg2 ;
78627   float arg3 ;
78628   float result;
78629
78630   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78631   arg2 = (float)jarg2;
78632   arg3 = (float)jarg3;
78633   {
78634     try {
78635       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2,arg3);
78636     } catch (std::out_of_range& e) {
78637       {
78638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78639       };
78640     } catch (std::exception& e) {
78641       {
78642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78643       };
78644     } catch (Dali::DaliException e) {
78645       {
78646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78647       };
78648     } catch (...) {
78649       {
78650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78651       };
78652     }
78653   }
78654
78655   jresult = result;
78656   return jresult;
78657 }
78658
78659
78660 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_1(void * jarg1, float jarg2) {
78661   float jresult ;
78662   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78663   float arg2 ;
78664   float result;
78665
78666   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78667   arg2 = (float)jarg2;
78668   {
78669     try {
78670       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2);
78671     } catch (std::out_of_range& e) {
78672       {
78673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78674       };
78675     } catch (std::exception& e) {
78676       {
78677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78678       };
78679     } catch (Dali::DaliException e) {
78680       {
78681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78682       };
78683     } catch (...) {
78684       {
78685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78686       };
78687     }
78688   }
78689
78690   jresult = result;
78691   return jresult;
78692 }
78693
78694
78695 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
78696   float jresult ;
78697   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78698   unsigned int arg2 ;
78699   unsigned int *arg3 = 0 ;
78700   bool arg4 ;
78701   float result;
78702
78703   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78704   arg2 = (unsigned int)jarg2;
78705   arg3 = (unsigned int *)jarg3;
78706   arg4 = jarg4 ? true : false;
78707   {
78708     try {
78709       result = (float)((Dali::Toolkit::Ruler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
78710     } catch (std::out_of_range& e) {
78711       {
78712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78713       };
78714     } catch (std::exception& e) {
78715       {
78716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78717       };
78718     } catch (Dali::DaliException e) {
78719       {
78720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78721       };
78722     } catch (...) {
78723       {
78724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78725       };
78726     }
78727   }
78728
78729   jresult = result;
78730   return jresult;
78731 }
78732
78733
78734 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
78735   unsigned int jresult ;
78736   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78737   float arg2 ;
78738   bool arg3 ;
78739   unsigned int result;
78740
78741   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78742   arg2 = (float)jarg2;
78743   arg3 = jarg3 ? true : false;
78744   {
78745     try {
78746       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetPageFromPosition(arg2,arg3);
78747     } catch (std::out_of_range& e) {
78748       {
78749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78750       };
78751     } catch (std::exception& e) {
78752       {
78753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78754       };
78755     } catch (Dali::DaliException e) {
78756       {
78757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78758       };
78759     } catch (...) {
78760       {
78761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78762       };
78763     }
78764   }
78765
78766   jresult = result;
78767   return jresult;
78768 }
78769
78770
78771 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetTotalPages(void * jarg1) {
78772   unsigned int jresult ;
78773   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78774   unsigned int result;
78775
78776   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78777   {
78778     try {
78779       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetTotalPages();
78780     } catch (std::out_of_range& e) {
78781       {
78782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78783       };
78784     } catch (std::exception& e) {
78785       {
78786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78787       };
78788     } catch (Dali::DaliException e) {
78789       {
78790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78791       };
78792     } catch (...) {
78793       {
78794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78795       };
78796     }
78797   }
78798
78799   jresult = result;
78800   return jresult;
78801 }
78802
78803
78804 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Ruler_GetType(void * jarg1) {
78805   int jresult ;
78806   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78807   Dali::Toolkit::Ruler::RulerType result;
78808
78809   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78810   {
78811     try {
78812       result = (Dali::Toolkit::Ruler::RulerType)((Dali::Toolkit::Ruler const *)arg1)->GetType();
78813     } catch (std::out_of_range& e) {
78814       {
78815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78816       };
78817     } catch (std::exception& e) {
78818       {
78819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78820       };
78821     } catch (Dali::DaliException e) {
78822       {
78823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78824       };
78825     } catch (...) {
78826       {
78827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78828       };
78829     }
78830   }
78831
78832   jresult = (int)result;
78833   return jresult;
78834 }
78835
78836
78837 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_IsEnabled(void * jarg1) {
78838   unsigned int jresult ;
78839   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78840   bool result;
78841
78842   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78843   {
78844     try {
78845       result = (bool)((Dali::Toolkit::Ruler const *)arg1)->IsEnabled();
78846     } catch (std::out_of_range& e) {
78847       {
78848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78849       };
78850     } catch (std::exception& e) {
78851       {
78852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78853       };
78854     } catch (Dali::DaliException e) {
78855       {
78856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78857       };
78858     } catch (...) {
78859       {
78860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78861       };
78862     }
78863   }
78864
78865   jresult = result;
78866   return jresult;
78867 }
78868
78869
78870 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Enable(void * jarg1) {
78871   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78872
78873   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78874   {
78875     try {
78876       (arg1)->Enable();
78877     } catch (std::out_of_range& e) {
78878       {
78879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78880       };
78881     } catch (std::exception& e) {
78882       {
78883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78884       };
78885     } catch (Dali::DaliException e) {
78886       {
78887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78888       };
78889     } catch (...) {
78890       {
78891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78892       };
78893     }
78894   }
78895
78896 }
78897
78898
78899 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Disable(void * jarg1) {
78900   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78901
78902   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78903   {
78904     try {
78905       (arg1)->Disable();
78906     } catch (std::out_of_range& e) {
78907       {
78908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78909       };
78910     } catch (std::exception& e) {
78911       {
78912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78913       };
78914     } catch (Dali::DaliException e) {
78915       {
78916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78917       };
78918     } catch (...) {
78919       {
78920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78921       };
78922     }
78923   }
78924
78925 }
78926
78927
78928 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_SetDomain(void * jarg1, void * jarg2) {
78929   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78930   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
78931   Dali::Toolkit::RulerDomain *argp2 ;
78932
78933   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78934   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
78935   if (!argp2) {
78936     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
78937     return ;
78938   }
78939   arg2 = *argp2;
78940   {
78941     try {
78942       (arg1)->SetDomain(arg2);
78943     } catch (std::out_of_range& e) {
78944       {
78945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78946       };
78947     } catch (std::exception& e) {
78948       {
78949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78950       };
78951     } catch (Dali::DaliException e) {
78952       {
78953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78954       };
78955     } catch (...) {
78956       {
78957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78958       };
78959     }
78960   }
78961
78962 }
78963
78964
78965 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Ruler_GetDomain(void * jarg1) {
78966   void * jresult ;
78967   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78968   Dali::Toolkit::RulerDomain *result = 0 ;
78969
78970   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78971   {
78972     try {
78973       result = (Dali::Toolkit::RulerDomain *) &((Dali::Toolkit::Ruler const *)arg1)->GetDomain();
78974     } catch (std::out_of_range& e) {
78975       {
78976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78977       };
78978     } catch (std::exception& e) {
78979       {
78980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78981       };
78982     } catch (Dali::DaliException e) {
78983       {
78984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78985       };
78986     } catch (...) {
78987       {
78988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78989       };
78990     }
78991   }
78992
78993   jresult = (void *)result;
78994   return jresult;
78995 }
78996
78997
78998 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_DisableDomain(void * jarg1) {
78999   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
79000
79001   arg1 = (Dali::Toolkit::Ruler *)jarg1;
79002   {
79003     try {
79004       (arg1)->DisableDomain();
79005     } catch (std::out_of_range& e) {
79006       {
79007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79008       };
79009     } catch (std::exception& e) {
79010       {
79011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79012       };
79013     } catch (Dali::DaliException e) {
79014       {
79015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79016       };
79017     } catch (...) {
79018       {
79019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79020       };
79021     }
79022   }
79023
79024 }
79025
79026
79027 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
79028   float jresult ;
79029   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
79030   float arg2 ;
79031   float arg3 ;
79032   float arg4 ;
79033   float result;
79034
79035   arg1 = (Dali::Toolkit::Ruler *)jarg1;
79036   arg2 = (float)jarg2;
79037   arg3 = (float)jarg3;
79038   arg4 = (float)jarg4;
79039   {
79040     try {
79041       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4);
79042     } catch (std::out_of_range& e) {
79043       {
79044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79045       };
79046     } catch (std::exception& e) {
79047       {
79048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79049       };
79050     } catch (Dali::DaliException e) {
79051       {
79052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79053       };
79054     } catch (...) {
79055       {
79056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79057       };
79058     }
79059   }
79060
79061   jresult = result;
79062   return jresult;
79063 }
79064
79065
79066 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
79067   float jresult ;
79068   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
79069   float arg2 ;
79070   float arg3 ;
79071   float result;
79072
79073   arg1 = (Dali::Toolkit::Ruler *)jarg1;
79074   arg2 = (float)jarg2;
79075   arg3 = (float)jarg3;
79076   {
79077     try {
79078       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3);
79079     } catch (std::out_of_range& e) {
79080       {
79081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79082       };
79083     } catch (std::exception& e) {
79084       {
79085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79086       };
79087     } catch (Dali::DaliException e) {
79088       {
79089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79090       };
79091     } catch (...) {
79092       {
79093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79094       };
79095     }
79096   }
79097
79098   jresult = result;
79099   return jresult;
79100 }
79101
79102
79103 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_2(void * jarg1, float jarg2) {
79104   float jresult ;
79105   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
79106   float arg2 ;
79107   float result;
79108
79109   arg1 = (Dali::Toolkit::Ruler *)jarg1;
79110   arg2 = (float)jarg2;
79111   {
79112     try {
79113       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2);
79114     } catch (std::out_of_range& e) {
79115       {
79116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79117       };
79118     } catch (std::exception& e) {
79119       {
79120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79121       };
79122     } catch (Dali::DaliException e) {
79123       {
79124         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79125       };
79126     } catch (...) {
79127       {
79128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79129       };
79130     }
79131   }
79132
79133   jresult = result;
79134   return jresult;
79135 }
79136
79137
79138 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
79139   float jresult ;
79140   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
79141   float arg2 ;
79142   float arg3 ;
79143   float arg4 ;
79144   Dali::Toolkit::ClampState *arg5 = 0 ;
79145   float result;
79146
79147   arg1 = (Dali::Toolkit::Ruler *)jarg1;
79148   arg2 = (float)jarg2;
79149   arg3 = (float)jarg3;
79150   arg4 = (float)jarg4;
79151   arg5 = (Dali::Toolkit::ClampState *)jarg5;
79152   if (!arg5) {
79153     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
79154     return 0;
79155   }
79156   {
79157     try {
79158       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
79159     } catch (std::out_of_range& e) {
79160       {
79161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79162       };
79163     } catch (std::exception& e) {
79164       {
79165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79166       };
79167     } catch (Dali::DaliException e) {
79168       {
79169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79170       };
79171     } catch (...) {
79172       {
79173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79174       };
79175     }
79176   }
79177
79178   jresult = result;
79179   return jresult;
79180 }
79181
79182
79183 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
79184   float jresult ;
79185   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
79186   float arg2 ;
79187   float arg3 ;
79188   float arg4 ;
79189   float arg5 ;
79190   float result;
79191
79192   arg1 = (Dali::Toolkit::Ruler *)jarg1;
79193   arg2 = (float)jarg2;
79194   arg3 = (float)jarg3;
79195   arg4 = (float)jarg4;
79196   arg5 = (float)jarg5;
79197   {
79198     try {
79199       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
79200     } catch (std::out_of_range& e) {
79201       {
79202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79203       };
79204     } catch (std::exception& e) {
79205       {
79206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79207       };
79208     } catch (Dali::DaliException e) {
79209       {
79210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79211       };
79212     } catch (...) {
79213       {
79214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79215       };
79216     }
79217   }
79218
79219   jresult = result;
79220   return jresult;
79221 }
79222
79223
79224 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
79225   float jresult ;
79226   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
79227   float arg2 ;
79228   float arg3 ;
79229   float arg4 ;
79230   float result;
79231
79232   arg1 = (Dali::Toolkit::Ruler *)jarg1;
79233   arg2 = (float)jarg2;
79234   arg3 = (float)jarg3;
79235   arg4 = (float)jarg4;
79236   {
79237     try {
79238       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4);
79239     } catch (std::out_of_range& e) {
79240       {
79241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79242       };
79243     } catch (std::exception& e) {
79244       {
79245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79246       };
79247     } catch (Dali::DaliException e) {
79248       {
79249         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79250       };
79251     } catch (...) {
79252       {
79253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79254       };
79255     }
79256   }
79257
79258   jresult = result;
79259   return jresult;
79260 }
79261
79262
79263 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
79264   float jresult ;
79265   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
79266   float arg2 ;
79267   float arg3 ;
79268   float result;
79269
79270   arg1 = (Dali::Toolkit::Ruler *)jarg1;
79271   arg2 = (float)jarg2;
79272   arg3 = (float)jarg3;
79273   {
79274     try {
79275       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3);
79276     } catch (std::out_of_range& e) {
79277       {
79278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79279       };
79280     } catch (std::exception& e) {
79281       {
79282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79283       };
79284     } catch (Dali::DaliException e) {
79285       {
79286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79287       };
79288     } catch (...) {
79289       {
79290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79291       };
79292     }
79293   }
79294
79295   jresult = result;
79296   return jresult;
79297 }
79298
79299
79300 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
79301   float jresult ;
79302   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
79303   float arg2 ;
79304   float result;
79305
79306   arg1 = (Dali::Toolkit::Ruler *)jarg1;
79307   arg2 = (float)jarg2;
79308   {
79309     try {
79310       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2);
79311     } catch (std::out_of_range& e) {
79312       {
79313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79314       };
79315     } catch (std::exception& e) {
79316       {
79317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79318       };
79319     } catch (Dali::DaliException e) {
79320       {
79321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79322       };
79323     } catch (...) {
79324       {
79325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79326       };
79327     }
79328   }
79329
79330   jresult = result;
79331   return jresult;
79332 }
79333
79334
79335 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
79336   float jresult ;
79337   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
79338   float arg2 ;
79339   float arg3 ;
79340   float arg4 ;
79341   float arg5 ;
79342   Dali::Toolkit::ClampState *arg6 = 0 ;
79343   float result;
79344
79345   arg1 = (Dali::Toolkit::Ruler *)jarg1;
79346   arg2 = (float)jarg2;
79347   arg3 = (float)jarg3;
79348   arg4 = (float)jarg4;
79349   arg5 = (float)jarg5;
79350   arg6 = (Dali::Toolkit::ClampState *)jarg6;
79351   if (!arg6) {
79352     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
79353     return 0;
79354   }
79355   {
79356     try {
79357       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
79358     } catch (std::out_of_range& e) {
79359       {
79360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79361       };
79362     } catch (std::exception& e) {
79363       {
79364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79365       };
79366     } catch (Dali::DaliException e) {
79367       {
79368         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79369       };
79370     } catch (...) {
79371       {
79372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79373       };
79374     }
79375   }
79376
79377   jresult = result;
79378   return jresult;
79379 }
79380
79381
79382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DefaultRuler() {
79383   void * jresult ;
79384   Dali::Toolkit::DefaultRuler *result = 0 ;
79385
79386   {
79387     try {
79388       result = (Dali::Toolkit::DefaultRuler *)new Dali::Toolkit::DefaultRuler();
79389     } catch (std::out_of_range& e) {
79390       {
79391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79392       };
79393     } catch (std::exception& e) {
79394       {
79395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79396       };
79397     } catch (Dali::DaliException e) {
79398       {
79399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79400       };
79401     } catch (...) {
79402       {
79403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79404       };
79405     }
79406   }
79407
79408   jresult = (void *)result;
79409   return jresult;
79410 }
79411
79412
79413 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_Snap(void * jarg1, float jarg2, float jarg3) {
79414   float jresult ;
79415   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
79416   float arg2 ;
79417   float arg3 ;
79418   float result;
79419
79420   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
79421   arg2 = (float)jarg2;
79422   arg3 = (float)jarg3;
79423   {
79424     try {
79425       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->Snap(arg2,arg3);
79426     } catch (std::out_of_range& e) {
79427       {
79428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79429       };
79430     } catch (std::exception& e) {
79431       {
79432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79433       };
79434     } catch (Dali::DaliException e) {
79435       {
79436         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79437       };
79438     } catch (...) {
79439       {
79440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79441       };
79442     }
79443   }
79444
79445   jresult = result;
79446   return jresult;
79447 }
79448
79449
79450 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
79451   float jresult ;
79452   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
79453   unsigned int arg2 ;
79454   unsigned int *arg3 = 0 ;
79455   bool arg4 ;
79456   float result;
79457
79458   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
79459   arg2 = (unsigned int)jarg2;
79460   arg3 = (unsigned int *)jarg3;
79461   arg4 = jarg4 ? true : false;
79462   {
79463     try {
79464       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
79465     } catch (std::out_of_range& e) {
79466       {
79467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79468       };
79469     } catch (std::exception& e) {
79470       {
79471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79472       };
79473     } catch (Dali::DaliException e) {
79474       {
79475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79476       };
79477     } catch (...) {
79478       {
79479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79480       };
79481     }
79482   }
79483
79484   jresult = result;
79485   return jresult;
79486 }
79487
79488
79489 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
79490   unsigned int jresult ;
79491   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
79492   float arg2 ;
79493   bool arg3 ;
79494   unsigned int result;
79495
79496   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
79497   arg2 = (float)jarg2;
79498   arg3 = jarg3 ? true : false;
79499   {
79500     try {
79501       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
79502     } catch (std::out_of_range& e) {
79503       {
79504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79505       };
79506     } catch (std::exception& e) {
79507       {
79508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79509       };
79510     } catch (Dali::DaliException e) {
79511       {
79512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79513       };
79514     } catch (...) {
79515       {
79516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79517       };
79518     }
79519   }
79520
79521   jresult = result;
79522   return jresult;
79523 }
79524
79525
79526 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetTotalPages(void * jarg1) {
79527   unsigned int jresult ;
79528   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
79529   unsigned int result;
79530
79531   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
79532   {
79533     try {
79534       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetTotalPages();
79535     } catch (std::out_of_range& e) {
79536       {
79537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79538       };
79539     } catch (std::exception& e) {
79540       {
79541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79542       };
79543     } catch (Dali::DaliException e) {
79544       {
79545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79546       };
79547     } catch (...) {
79548       {
79549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79550       };
79551     }
79552   }
79553
79554   jresult = result;
79555   return jresult;
79556 }
79557
79558
79559 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DefaultRuler(void * jarg1) {
79560   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
79561
79562   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
79563   {
79564     try {
79565       delete arg1;
79566     } catch (std::out_of_range& e) {
79567       {
79568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79569       };
79570     } catch (std::exception& e) {
79571       {
79572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79573       };
79574     } catch (Dali::DaliException e) {
79575       {
79576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79577       };
79578     } catch (...) {
79579       {
79580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79581       };
79582     }
79583   }
79584
79585 }
79586
79587
79588 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_0(float jarg1) {
79589   void * jresult ;
79590   float arg1 ;
79591   Dali::Toolkit::FixedRuler *result = 0 ;
79592
79593   arg1 = (float)jarg1;
79594   {
79595     try {
79596       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler(arg1);
79597     } catch (std::out_of_range& e) {
79598       {
79599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79600       };
79601     } catch (std::exception& e) {
79602       {
79603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79604       };
79605     } catch (Dali::DaliException e) {
79606       {
79607         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79608       };
79609     } catch (...) {
79610       {
79611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79612       };
79613     }
79614   }
79615
79616   jresult = (void *)result;
79617   return jresult;
79618 }
79619
79620
79621 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_1() {
79622   void * jresult ;
79623   Dali::Toolkit::FixedRuler *result = 0 ;
79624
79625   {
79626     try {
79627       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler();
79628     } catch (std::out_of_range& e) {
79629       {
79630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79631       };
79632     } catch (std::exception& e) {
79633       {
79634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79635       };
79636     } catch (Dali::DaliException e) {
79637       {
79638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79639       };
79640     } catch (...) {
79641       {
79642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79643       };
79644     }
79645   }
79646
79647   jresult = (void *)result;
79648   return jresult;
79649 }
79650
79651
79652 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_Snap(void * jarg1, float jarg2, float jarg3) {
79653   float jresult ;
79654   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79655   float arg2 ;
79656   float arg3 ;
79657   float result;
79658
79659   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79660   arg2 = (float)jarg2;
79661   arg3 = (float)jarg3;
79662   {
79663     try {
79664       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->Snap(arg2,arg3);
79665     } catch (std::out_of_range& e) {
79666       {
79667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79668       };
79669     } catch (std::exception& e) {
79670       {
79671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79672       };
79673     } catch (Dali::DaliException e) {
79674       {
79675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79676       };
79677     } catch (...) {
79678       {
79679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79680       };
79681     }
79682   }
79683
79684   jresult = result;
79685   return jresult;
79686 }
79687
79688
79689 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
79690   float jresult ;
79691   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79692   unsigned int arg2 ;
79693   unsigned int *arg3 = 0 ;
79694   bool arg4 ;
79695   float result;
79696
79697   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79698   arg2 = (unsigned int)jarg2;
79699   arg3 = (unsigned int *)jarg3;
79700   arg4 = jarg4 ? true : false;
79701   {
79702     try {
79703       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
79704     } catch (std::out_of_range& e) {
79705       {
79706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79707       };
79708     } catch (std::exception& e) {
79709       {
79710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79711       };
79712     } catch (Dali::DaliException e) {
79713       {
79714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79715       };
79716     } catch (...) {
79717       {
79718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79719       };
79720     }
79721   }
79722
79723   jresult = result;
79724   return jresult;
79725 }
79726
79727
79728 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
79729   unsigned int jresult ;
79730   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79731   float arg2 ;
79732   bool arg3 ;
79733   unsigned int result;
79734
79735   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79736   arg2 = (float)jarg2;
79737   arg3 = jarg3 ? true : false;
79738   {
79739     try {
79740       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
79741     } catch (std::out_of_range& e) {
79742       {
79743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79744       };
79745     } catch (std::exception& e) {
79746       {
79747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79748       };
79749     } catch (Dali::DaliException e) {
79750       {
79751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79752       };
79753     } catch (...) {
79754       {
79755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79756       };
79757     }
79758   }
79759
79760   jresult = result;
79761   return jresult;
79762 }
79763
79764
79765 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetTotalPages(void * jarg1) {
79766   unsigned int jresult ;
79767   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79768   unsigned int result;
79769
79770   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79771   {
79772     try {
79773       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetTotalPages();
79774     } catch (std::out_of_range& e) {
79775       {
79776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79777       };
79778     } catch (std::exception& e) {
79779       {
79780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79781       };
79782     } catch (Dali::DaliException e) {
79783       {
79784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79785       };
79786     } catch (...) {
79787       {
79788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79789       };
79790     }
79791   }
79792
79793   jresult = result;
79794   return jresult;
79795 }
79796
79797
79798 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FixedRuler(void * jarg1) {
79799   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79800
79801   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79802   {
79803     try {
79804       delete arg1;
79805     } catch (std::out_of_range& e) {
79806       {
79807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79808       };
79809     } catch (std::exception& e) {
79810       {
79811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79812       };
79813     } catch (Dali::DaliException e) {
79814       {
79815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79816       };
79817     } catch (...) {
79818       {
79819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79820       };
79821     }
79822   }
79823
79824 }
79825
79826
79827 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_set(void * jarg1, void * jarg2) {
79828   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79829   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
79830
79831   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79832   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
79833   if (arg1) (arg1)->scale = *arg2;
79834 }
79835
79836
79837 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_get(void * jarg1) {
79838   void * jresult ;
79839   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79840   Dali::Toolkit::ClampState2D *result = 0 ;
79841
79842   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79843   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->scale);
79844   jresult = (void *)result;
79845   return jresult;
79846 }
79847
79848
79849 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_set(void * jarg1, void * jarg2) {
79850   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79851   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
79852
79853   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79854   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
79855   if (arg1) (arg1)->position = *arg2;
79856 }
79857
79858
79859 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_get(void * jarg1) {
79860   void * jresult ;
79861   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79862   Dali::Toolkit::ClampState2D *result = 0 ;
79863
79864   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79865   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->position);
79866   jresult = (void *)result;
79867   return jresult;
79868 }
79869
79870
79871 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_set(void * jarg1, int jarg2) {
79872   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79873   Dali::Toolkit::ClampState arg2 ;
79874
79875   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79876   arg2 = (Dali::Toolkit::ClampState)jarg2;
79877   if (arg1) (arg1)->rotation = arg2;
79878 }
79879
79880
79881 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_get(void * jarg1) {
79882   int jresult ;
79883   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79884   Dali::Toolkit::ClampState result;
79885
79886   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79887   result = (Dali::Toolkit::ClampState) ((arg1)->rotation);
79888   jresult = (int)result;
79889   return jresult;
79890 }
79891
79892
79893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_ClampEvent() {
79894   void * jresult ;
79895   Dali::Toolkit::ScrollView::ClampEvent *result = 0 ;
79896
79897   {
79898     try {
79899       result = (Dali::Toolkit::ScrollView::ClampEvent *)new Dali::Toolkit::ScrollView::ClampEvent();
79900     } catch (std::out_of_range& e) {
79901       {
79902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79903       };
79904     } catch (std::exception& e) {
79905       {
79906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79907       };
79908     } catch (Dali::DaliException e) {
79909       {
79910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79911       };
79912     } catch (...) {
79913       {
79914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79915       };
79916     }
79917   }
79918
79919   jresult = (void *)result;
79920   return jresult;
79921 }
79922
79923
79924 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_ClampEvent(void * jarg1) {
79925   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79926
79927   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79928   {
79929     try {
79930       delete arg1;
79931     } catch (std::out_of_range& e) {
79932       {
79933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79934       };
79935     } catch (std::exception& e) {
79936       {
79937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79938       };
79939     } catch (Dali::DaliException e) {
79940       {
79941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79942       };
79943     } catch (...) {
79944       {
79945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79946       };
79947     }
79948   }
79949
79950 }
79951
79952
79953 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_set(void * jarg1, int jarg2) {
79954   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79955   Dali::Toolkit::SnapType arg2 ;
79956
79957   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79958   arg2 = (Dali::Toolkit::SnapType)jarg2;
79959   if (arg1) (arg1)->type = arg2;
79960 }
79961
79962
79963 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_get(void * jarg1) {
79964   int jresult ;
79965   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79966   Dali::Toolkit::SnapType result;
79967
79968   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79969   result = (Dali::Toolkit::SnapType) ((arg1)->type);
79970   jresult = (int)result;
79971   return jresult;
79972 }
79973
79974
79975 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_set(void * jarg1, void * jarg2) {
79976   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79977   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
79978
79979   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79980   arg2 = (Dali::Vector2 *)jarg2;
79981   if (arg1) (arg1)->position = *arg2;
79982 }
79983
79984
79985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_get(void * jarg1) {
79986   void * jresult ;
79987   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79988   Dali::Vector2 *result = 0 ;
79989
79990   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79991   result = (Dali::Vector2 *)& ((arg1)->position);
79992   jresult = (void *)result;
79993   return jresult;
79994 }
79995
79996
79997 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_set(void * jarg1, float jarg2) {
79998   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79999   float arg2 ;
80000
80001   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
80002   arg2 = (float)jarg2;
80003   if (arg1) (arg1)->duration = arg2;
80004 }
80005
80006
80007 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_get(void * jarg1) {
80008   float jresult ;
80009   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
80010   float result;
80011
80012   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
80013   result = (float) ((arg1)->duration);
80014   jresult = result;
80015   return jresult;
80016 }
80017
80018
80019 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_SnapEvent() {
80020   void * jresult ;
80021   Dali::Toolkit::ScrollView::SnapEvent *result = 0 ;
80022
80023   {
80024     try {
80025       result = (Dali::Toolkit::ScrollView::SnapEvent *)new Dali::Toolkit::ScrollView::SnapEvent();
80026     } catch (std::out_of_range& e) {
80027       {
80028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80029       };
80030     } catch (std::exception& e) {
80031       {
80032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80033       };
80034     } catch (Dali::DaliException e) {
80035       {
80036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80037       };
80038     } catch (...) {
80039       {
80040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80041       };
80042     }
80043   }
80044
80045   jresult = (void *)result;
80046   return jresult;
80047 }
80048
80049
80050 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_SnapEvent(void * jarg1) {
80051   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
80052
80053   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
80054   {
80055     try {
80056       delete arg1;
80057     } catch (std::out_of_range& e) {
80058       {
80059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80060       };
80061     } catch (std::exception& e) {
80062       {
80063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80064       };
80065     } catch (Dali::DaliException e) {
80066       {
80067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80068       };
80069     } catch (...) {
80070       {
80071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80072       };
80073     }
80074   }
80075
80076 }
80077
80078
80079 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_ENABLED_get() {
80080   int jresult ;
80081   int result;
80082
80083   result = (int)Dali::Toolkit::ScrollView::Property::WRAP_ENABLED;
80084   jresult = (int)result;
80085   return jresult;
80086 }
80087
80088
80089 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_ENABLED_get() {
80090   int jresult ;
80091   int result;
80092
80093   result = (int)Dali::Toolkit::ScrollView::Property::PANNING_ENABLED;
80094   jresult = (int)result;
80095   return jresult;
80096 }
80097
80098
80099 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_AXIS_AUTO_LOCK_ENABLED_get() {
80100   int jresult ;
80101   int result;
80102
80103   result = (int)Dali::Toolkit::ScrollView::Property::AXIS_AUTO_LOCK_ENABLED;
80104   jresult = (int)result;
80105   return jresult;
80106 }
80107
80108
80109 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
80110   int jresult ;
80111   int result;
80112
80113   result = (int)Dali::Toolkit::ScrollView::Property::WHEEL_SCROLL_DISTANCE_STEP;
80114   jresult = (int)result;
80115   return jresult;
80116 }
80117
80118
80119 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_MODE_get() {
80120   int jresult ;
80121   int result;
80122
80123   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_MODE;
80124   jresult = (int)result;
80125   return jresult;
80126 }
80127
80128 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_get() {
80129   int jresult ;
80130   int result;
80131
80132   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION;
80133   jresult = (int)result;
80134   return jresult;
80135 }
80136
80137
80138 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_get() {
80139   int jresult ;
80140   int result;
80141
80142   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION;
80143   jresult = (int)result;
80144   return jresult;
80145 }
80146
80147
80148 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_X_get() {
80149   int jresult ;
80150   int result;
80151
80152   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_X;
80153   jresult = (int)result;
80154   return jresult;
80155 }
80156
80157
80158 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_Y_get() {
80159   int jresult ;
80160   int result;
80161
80162   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_Y;
80163   jresult = (int)result;
80164   return jresult;
80165 }
80166
80167
80168 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_get() {
80169   int jresult ;
80170   int result;
80171
80172   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX;
80173   jresult = (int)result;
80174   return jresult;
80175 }
80176
80177
80178 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_X_get() {
80179   int jresult ;
80180   int result;
80181
80182   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_X;
80183   jresult = (int)result;
80184   return jresult;
80185 }
80186
80187
80188 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_Y_get() {
80189   int jresult ;
80190   int result;
80191
80192   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_Y;
80193   jresult = (int)result;
80194   return jresult;
80195 }
80196
80197
80198 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_X_get() {
80199   int jresult ;
80200   int result;
80201
80202   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_X;
80203   jresult = (int)result;
80204   return jresult;
80205 }
80206
80207
80208 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_Y_get() {
80209   int jresult ;
80210   int result;
80211
80212   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_Y;
80213   jresult = (int)result;
80214   return jresult;
80215 }
80216
80217
80218 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_get() {
80219   int jresult ;
80220   int result;
80221
80222   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL;
80223   jresult = (int)result;
80224   return jresult;
80225 }
80226
80227
80228 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_X_get() {
80229   int jresult ;
80230   int result;
80231
80232   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_X;
80233   jresult = (int)result;
80234   return jresult;
80235 }
80236
80237
80238 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_Y_get() {
80239   int jresult ;
80240   int result;
80241
80242   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_Y;
80243   jresult = (int)result;
80244   return jresult;
80245 }
80246
80247
80248 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_get() {
80249   int jresult ;
80250   int result;
80251
80252   result = (int)Dali::Toolkit::ScrollView::Property::WRAP;
80253   jresult = (int)result;
80254   return jresult;
80255 }
80256
80257
80258 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_get() {
80259   int jresult ;
80260   int result;
80261
80262   result = (int)Dali::Toolkit::ScrollView::Property::PANNING;
80263   jresult = (int)result;
80264   return jresult;
80265 }
80266
80267
80268 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLLING_get() {
80269   int jresult ;
80270   int result;
80271
80272   result = (int)Dali::Toolkit::ScrollView::Property::SCROLLING;
80273   jresult = (int)result;
80274   return jresult;
80275 }
80276
80277
80278 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_get() {
80279   int jresult ;
80280   int result;
80281
80282   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE;
80283   jresult = (int)result;
80284   return jresult;
80285 }
80286
80287
80288 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_X_get() {
80289   int jresult ;
80290   int result;
80291
80292   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_X;
80293   jresult = (int)result;
80294   return jresult;
80295 }
80296
80297
80298 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_Y_get() {
80299   int jresult ;
80300   int result;
80301
80302   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_Y;
80303   jresult = (int)result;
80304   return jresult;
80305 }
80306
80307
80308 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_OFFSET_get() {
80309   int jresult ;
80310   int result;
80311
80312   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_OFFSET;
80313   jresult = (int)result;
80314   return jresult;
80315 }
80316
80317
80318 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_DELTA_get() {
80319   int jresult ;
80320   int result;
80321
80322   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION_DELTA;
80323   jresult = (int)result;
80324   return jresult;
80325 }
80326
80327
80328 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_START_PAGE_POSITION_get() {
80329   int jresult ;
80330   int result;
80331
80332   result = (int)Dali::Toolkit::ScrollView::Property::START_PAGE_POSITION;
80333   jresult = (int)result;
80334   return jresult;
80335 }
80336
80337
80338 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_Property() {
80339   void * jresult ;
80340   Dali::Toolkit::ScrollView::Property *result = 0 ;
80341
80342   {
80343     try {
80344       result = (Dali::Toolkit::ScrollView::Property *)new Dali::Toolkit::ScrollView::Property();
80345     } catch (std::out_of_range& e) {
80346       {
80347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80348       };
80349     } catch (std::exception& e) {
80350       {
80351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80352       };
80353     } catch (Dali::DaliException e) {
80354       {
80355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80356       };
80357     } catch (...) {
80358       {
80359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80360       };
80361     }
80362   }
80363
80364   jresult = (void *)result;
80365   return jresult;
80366 }
80367
80368
80369 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_Property(void * jarg1) {
80370   Dali::Toolkit::ScrollView::Property *arg1 = (Dali::Toolkit::ScrollView::Property *) 0 ;
80371
80372   arg1 = (Dali::Toolkit::ScrollView::Property *)jarg1;
80373   {
80374     try {
80375       delete arg1;
80376     } catch (std::out_of_range& e) {
80377       {
80378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80379       };
80380     } catch (std::exception& e) {
80381       {
80382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80383       };
80384     } catch (Dali::DaliException e) {
80385       {
80386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80387       };
80388     } catch (...) {
80389       {
80390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80391       };
80392     }
80393   }
80394
80395 }
80396
80397
80398 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_0() {
80399   void * jresult ;
80400   Dali::Toolkit::ScrollView *result = 0 ;
80401
80402   {
80403     try {
80404       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView();
80405     } catch (std::out_of_range& e) {
80406       {
80407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80408       };
80409     } catch (std::exception& e) {
80410       {
80411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80412       };
80413     } catch (Dali::DaliException e) {
80414       {
80415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80416       };
80417     } catch (...) {
80418       {
80419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80420       };
80421     }
80422   }
80423
80424   jresult = (void *)result;
80425   return jresult;
80426 }
80427
80428
80429 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_1(void * jarg1) {
80430   void * jresult ;
80431   Dali::Toolkit::ScrollView *arg1 = 0 ;
80432   Dali::Toolkit::ScrollView *result = 0 ;
80433
80434   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80435   if (!arg1) {
80436     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
80437     return 0;
80438   }
80439   {
80440     try {
80441       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView((Dali::Toolkit::ScrollView const &)*arg1);
80442     } catch (std::out_of_range& e) {
80443       {
80444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80445       };
80446     } catch (std::exception& e) {
80447       {
80448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80449       };
80450     } catch (Dali::DaliException e) {
80451       {
80452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80453       };
80454     } catch (...) {
80455       {
80456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80457       };
80458     }
80459   }
80460
80461   jresult = (void *)result;
80462   return jresult;
80463 }
80464
80465
80466 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_Assign(void * jarg1, void * jarg2) {
80467   void * jresult ;
80468   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80469   Dali::Toolkit::ScrollView *arg2 = 0 ;
80470   Dali::Toolkit::ScrollView *result = 0 ;
80471
80472   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80473   arg2 = (Dali::Toolkit::ScrollView *)jarg2;
80474   if (!arg2) {
80475     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
80476     return 0;
80477   }
80478   {
80479     try {
80480       result = (Dali::Toolkit::ScrollView *) &(arg1)->operator =((Dali::Toolkit::ScrollView const &)*arg2);
80481     } catch (std::out_of_range& e) {
80482       {
80483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80484       };
80485     } catch (std::exception& e) {
80486       {
80487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80488       };
80489     } catch (Dali::DaliException e) {
80490       {
80491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80492       };
80493     } catch (...) {
80494       {
80495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80496       };
80497     }
80498   }
80499
80500   jresult = (void *)result;
80501   return jresult;
80502 }
80503
80504
80505 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView(void * jarg1) {
80506   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80507
80508   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80509   {
80510     try {
80511       delete arg1;
80512     } catch (std::out_of_range& e) {
80513       {
80514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80515       };
80516     } catch (std::exception& e) {
80517       {
80518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80519       };
80520     } catch (Dali::DaliException e) {
80521       {
80522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80523       };
80524     } catch (...) {
80525       {
80526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80527       };
80528     }
80529   }
80530
80531 }
80532
80533
80534 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_New() {
80535   void * jresult ;
80536   Dali::Toolkit::ScrollView result;
80537
80538   {
80539     try {
80540       result = Dali::Toolkit::ScrollView::New();
80541     } catch (std::out_of_range& e) {
80542       {
80543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80544       };
80545     } catch (std::exception& e) {
80546       {
80547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80548       };
80549     } catch (Dali::DaliException e) {
80550       {
80551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80552       };
80553     } catch (...) {
80554       {
80555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80556       };
80557     }
80558   }
80559
80560   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
80561   return jresult;
80562 }
80563
80564
80565 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_DownCast(void * jarg1) {
80566   void * jresult ;
80567   Dali::BaseHandle arg1 ;
80568   Dali::BaseHandle *argp1 ;
80569   Dali::Toolkit::ScrollView result;
80570
80571   argp1 = (Dali::BaseHandle *)jarg1;
80572   if (!argp1) {
80573     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
80574     return 0;
80575   }
80576   arg1 = *argp1;
80577   {
80578     try {
80579       result = Dali::Toolkit::ScrollView::DownCast(arg1);
80580     } catch (std::out_of_range& e) {
80581       {
80582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80583       };
80584     } catch (std::exception& e) {
80585       {
80586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80587       };
80588     } catch (Dali::DaliException e) {
80589       {
80590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80591       };
80592     } catch (...) {
80593       {
80594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80595       };
80596     }
80597   }
80598
80599   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
80600   return jresult;
80601 }
80602
80603
80604 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapAlphaFunction(void * jarg1) {
80605   void * jresult ;
80606   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80607   Dali::AlphaFunction result;
80608
80609   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80610   {
80611     try {
80612       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapAlphaFunction();
80613     } catch (std::out_of_range& e) {
80614       {
80615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80616       };
80617     } catch (std::exception& e) {
80618       {
80619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80620       };
80621     } catch (Dali::DaliException e) {
80622       {
80623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80624       };
80625     } catch (...) {
80626       {
80627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80628       };
80629     }
80630   }
80631
80632   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
80633   return jresult;
80634 }
80635
80636
80637 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapAlphaFunction(void * jarg1, void * jarg2) {
80638   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80639   Dali::AlphaFunction arg2 ;
80640   Dali::AlphaFunction *argp2 ;
80641
80642   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80643   argp2 = (Dali::AlphaFunction *)jarg2;
80644   if (!argp2) {
80645     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
80646     return ;
80647   }
80648   arg2 = *argp2;
80649   {
80650     try {
80651       (arg1)->SetScrollSnapAlphaFunction(arg2);
80652     } catch (std::out_of_range& e) {
80653       {
80654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80655       };
80656     } catch (std::exception& e) {
80657       {
80658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80659       };
80660     } catch (Dali::DaliException e) {
80661       {
80662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80663       };
80664     } catch (...) {
80665       {
80666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80667       };
80668     }
80669   }
80670
80671 }
80672
80673
80674 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickAlphaFunction(void * jarg1) {
80675   void * jresult ;
80676   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80677   Dali::AlphaFunction result;
80678
80679   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80680   {
80681     try {
80682       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickAlphaFunction();
80683     } catch (std::out_of_range& e) {
80684       {
80685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80686       };
80687     } catch (std::exception& e) {
80688       {
80689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80690       };
80691     } catch (Dali::DaliException e) {
80692       {
80693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80694       };
80695     } catch (...) {
80696       {
80697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80698       };
80699     }
80700   }
80701
80702   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
80703   return jresult;
80704 }
80705
80706
80707 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickAlphaFunction(void * jarg1, void * jarg2) {
80708   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80709   Dali::AlphaFunction arg2 ;
80710   Dali::AlphaFunction *argp2 ;
80711
80712   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80713   argp2 = (Dali::AlphaFunction *)jarg2;
80714   if (!argp2) {
80715     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
80716     return ;
80717   }
80718   arg2 = *argp2;
80719   {
80720     try {
80721       (arg1)->SetScrollFlickAlphaFunction(arg2);
80722     } catch (std::out_of_range& e) {
80723       {
80724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80725       };
80726     } catch (std::exception& e) {
80727       {
80728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80729       };
80730     } catch (Dali::DaliException e) {
80731       {
80732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80733       };
80734     } catch (...) {
80735       {
80736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80737       };
80738     }
80739   }
80740
80741 }
80742
80743
80744 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapDuration(void * jarg1) {
80745   float jresult ;
80746   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80747   float result;
80748
80749   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80750   {
80751     try {
80752       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapDuration();
80753     } catch (std::out_of_range& e) {
80754       {
80755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80756       };
80757     } catch (std::exception& e) {
80758       {
80759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80760       };
80761     } catch (Dali::DaliException e) {
80762       {
80763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80764       };
80765     } catch (...) {
80766       {
80767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80768       };
80769     }
80770   }
80771
80772   jresult = result;
80773   return jresult;
80774 }
80775
80776
80777 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapDuration(void * jarg1, float jarg2) {
80778   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80779   float arg2 ;
80780
80781   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80782   arg2 = (float)jarg2;
80783   {
80784     try {
80785       (arg1)->SetScrollSnapDuration(arg2);
80786     } catch (std::out_of_range& e) {
80787       {
80788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80789       };
80790     } catch (std::exception& e) {
80791       {
80792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80793       };
80794     } catch (Dali::DaliException e) {
80795       {
80796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80797       };
80798     } catch (...) {
80799       {
80800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80801       };
80802     }
80803   }
80804
80805 }
80806
80807
80808 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickDuration(void * jarg1) {
80809   float jresult ;
80810   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80811   float result;
80812
80813   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80814   {
80815     try {
80816       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickDuration();
80817     } catch (std::out_of_range& e) {
80818       {
80819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80820       };
80821     } catch (std::exception& e) {
80822       {
80823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80824       };
80825     } catch (Dali::DaliException e) {
80826       {
80827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80828       };
80829     } catch (...) {
80830       {
80831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80832       };
80833     }
80834   }
80835
80836   jresult = result;
80837   return jresult;
80838 }
80839
80840
80841 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickDuration(void * jarg1, float jarg2) {
80842   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80843   float arg2 ;
80844
80845   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80846   arg2 = (float)jarg2;
80847   {
80848     try {
80849       (arg1)->SetScrollFlickDuration(arg2);
80850     } catch (std::out_of_range& e) {
80851       {
80852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80853       };
80854     } catch (std::exception& e) {
80855       {
80856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80857       };
80858     } catch (Dali::DaliException e) {
80859       {
80860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80861       };
80862     } catch (...) {
80863       {
80864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80865       };
80866     }
80867   }
80868
80869 }
80870
80871
80872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerX(void * jarg1, void * jarg2) {
80873   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80874   Dali::Toolkit::RulerPtr arg2 ;
80875   Dali::Toolkit::RulerPtr *argp2 ;
80876
80877   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80878   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
80879   if (!argp2) {
80880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
80881     return ;
80882   }
80883   arg2 = *argp2;
80884   {
80885     try {
80886       (arg1)->SetRulerX(arg2);
80887     } catch (std::out_of_range& e) {
80888       {
80889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80890       };
80891     } catch (std::exception& e) {
80892       {
80893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80894       };
80895     } catch (Dali::DaliException e) {
80896       {
80897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80898       };
80899     } catch (...) {
80900       {
80901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80902       };
80903     }
80904   }
80905
80906 }
80907
80908
80909 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerY(void * jarg1, void * jarg2) {
80910   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80911   Dali::Toolkit::RulerPtr arg2 ;
80912   Dali::Toolkit::RulerPtr *argp2 ;
80913
80914   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80915   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
80916   if (!argp2) {
80917     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
80918     return ;
80919   }
80920   arg2 = *argp2;
80921   {
80922     try {
80923       (arg1)->SetRulerY(arg2);
80924     } catch (std::out_of_range& e) {
80925       {
80926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80927       };
80928     } catch (std::exception& e) {
80929       {
80930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80931       };
80932     } catch (Dali::DaliException e) {
80933       {
80934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80935       };
80936     } catch (...) {
80937       {
80938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80939       };
80940     }
80941   }
80942
80943 }
80944
80945
80946 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSensitive(void * jarg1, unsigned int jarg2) {
80947   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80948   bool arg2 ;
80949
80950   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80951   arg2 = jarg2 ? true : false;
80952   {
80953     try {
80954       (arg1)->SetScrollSensitive(arg2);
80955     } catch (std::out_of_range& e) {
80956       {
80957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80958       };
80959     } catch (std::exception& e) {
80960       {
80961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80962       };
80963     } catch (Dali::DaliException e) {
80964       {
80965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80966       };
80967     } catch (...) {
80968       {
80969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80970       };
80971     }
80972   }
80973
80974 }
80975
80976
80977 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxOvershoot(void * jarg1, float jarg2, float jarg3) {
80978   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80979   float arg2 ;
80980   float arg3 ;
80981
80982   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80983   arg2 = (float)jarg2;
80984   arg3 = (float)jarg3;
80985   {
80986     try {
80987       (arg1)->SetMaxOvershoot(arg2,arg3);
80988     } catch (std::out_of_range& e) {
80989       {
80990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80991       };
80992     } catch (std::exception& e) {
80993       {
80994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80995       };
80996     } catch (Dali::DaliException e) {
80997       {
80998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80999       };
81000     } catch (...) {
81001       {
81002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81003       };
81004     }
81005   }
81006
81007 }
81008
81009
81010 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootAlphaFunction(void * jarg1, void * jarg2) {
81011   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81012   Dali::AlphaFunction arg2 ;
81013   Dali::AlphaFunction *argp2 ;
81014
81015   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81016   argp2 = (Dali::AlphaFunction *)jarg2;
81017   if (!argp2) {
81018     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
81019     return ;
81020   }
81021   arg2 = *argp2;
81022   {
81023     try {
81024       (arg1)->SetSnapOvershootAlphaFunction(arg2);
81025     } catch (std::out_of_range& e) {
81026       {
81027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81028       };
81029     } catch (std::exception& e) {
81030       {
81031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81032       };
81033     } catch (Dali::DaliException e) {
81034       {
81035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81036       };
81037     } catch (...) {
81038       {
81039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81040       };
81041     }
81042   }
81043
81044 }
81045
81046
81047 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootDuration(void * jarg1, float jarg2) {
81048   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81049   float arg2 ;
81050
81051   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81052   arg2 = (float)jarg2;
81053   {
81054     try {
81055       (arg1)->SetSnapOvershootDuration(arg2);
81056     } catch (std::out_of_range& e) {
81057       {
81058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81059       };
81060     } catch (std::exception& e) {
81061       {
81062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81063       };
81064     } catch (Dali::DaliException e) {
81065       {
81066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81067       };
81068     } catch (...) {
81069       {
81070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81071       };
81072     }
81073   }
81074
81075 }
81076
81077
81078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetActorAutoSnap(void * jarg1, unsigned int jarg2) {
81079   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81080   bool arg2 ;
81081
81082   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81083   arg2 = jarg2 ? true : false;
81084   {
81085     try {
81086       (arg1)->SetActorAutoSnap(arg2);
81087     } catch (std::out_of_range& e) {
81088       {
81089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81090       };
81091     } catch (std::exception& e) {
81092       {
81093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81094       };
81095     } catch (Dali::DaliException e) {
81096       {
81097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81098       };
81099     } catch (...) {
81100       {
81101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81102       };
81103     }
81104   }
81105
81106 }
81107
81108
81109 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWrapMode(void * jarg1, unsigned int jarg2) {
81110   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81111   bool arg2 ;
81112
81113   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81114   arg2 = jarg2 ? true : false;
81115   {
81116     try {
81117       (arg1)->SetWrapMode(arg2);
81118     } catch (std::out_of_range& e) {
81119       {
81120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81121       };
81122     } catch (std::exception& e) {
81123       {
81124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81125       };
81126     } catch (Dali::DaliException e) {
81127       {
81128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81129       };
81130     } catch (...) {
81131       {
81132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81133       };
81134     }
81135   }
81136
81137 }
81138
81139
81140 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollUpdateDistance(void * jarg1) {
81141   int jresult ;
81142   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81143   int result;
81144
81145   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81146   {
81147     try {
81148       result = (int)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollUpdateDistance();
81149     } catch (std::out_of_range& e) {
81150       {
81151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81152       };
81153     } catch (std::exception& e) {
81154       {
81155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81156       };
81157     } catch (Dali::DaliException e) {
81158       {
81159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81160       };
81161     } catch (...) {
81162       {
81163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81164       };
81165     }
81166   }
81167
81168   jresult = result;
81169   return jresult;
81170 }
81171
81172
81173 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollUpdateDistance(void * jarg1, int jarg2) {
81174   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81175   int arg2 ;
81176
81177   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81178   arg2 = (int)jarg2;
81179   {
81180     try {
81181       (arg1)->SetScrollUpdateDistance(arg2);
81182     } catch (std::out_of_range& e) {
81183       {
81184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81185       };
81186     } catch (std::exception& e) {
81187       {
81188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81189       };
81190     } catch (Dali::DaliException e) {
81191       {
81192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81193       };
81194     } catch (...) {
81195       {
81196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81197       };
81198     }
81199   }
81200
81201 }
81202
81203
81204 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLock(void * jarg1) {
81205   unsigned int jresult ;
81206   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81207   bool result;
81208
81209   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81210   {
81211     try {
81212       result = (bool)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLock();
81213     } catch (std::out_of_range& e) {
81214       {
81215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81216       };
81217     } catch (std::exception& e) {
81218       {
81219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81220       };
81221     } catch (Dali::DaliException e) {
81222       {
81223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81224       };
81225     } catch (...) {
81226       {
81227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81228       };
81229     }
81230   }
81231
81232   jresult = result;
81233   return jresult;
81234 }
81235
81236
81237 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLock(void * jarg1, unsigned int jarg2) {
81238   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81239   bool arg2 ;
81240
81241   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81242   arg2 = jarg2 ? true : false;
81243   {
81244     try {
81245       (arg1)->SetAxisAutoLock(arg2);
81246     } catch (std::out_of_range& e) {
81247       {
81248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81249       };
81250     } catch (std::exception& e) {
81251       {
81252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81253       };
81254     } catch (Dali::DaliException e) {
81255       {
81256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81257       };
81258     } catch (...) {
81259       {
81260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81261       };
81262     }
81263   }
81264
81265 }
81266
81267
81268 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLockGradient(void * jarg1) {
81269   float jresult ;
81270   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81271   float result;
81272
81273   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81274   {
81275     try {
81276       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLockGradient();
81277     } catch (std::out_of_range& e) {
81278       {
81279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81280       };
81281     } catch (std::exception& e) {
81282       {
81283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81284       };
81285     } catch (Dali::DaliException e) {
81286       {
81287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81288       };
81289     } catch (...) {
81290       {
81291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81292       };
81293     }
81294   }
81295
81296   jresult = result;
81297   return jresult;
81298 }
81299
81300
81301 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLockGradient(void * jarg1, float jarg2) {
81302   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81303   float arg2 ;
81304
81305   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81306   arg2 = (float)jarg2;
81307   {
81308     try {
81309       (arg1)->SetAxisAutoLockGradient(arg2);
81310     } catch (std::out_of_range& e) {
81311       {
81312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81313       };
81314     } catch (std::exception& e) {
81315       {
81316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81317       };
81318     } catch (Dali::DaliException e) {
81319       {
81320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81321       };
81322     } catch (...) {
81323       {
81324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81325       };
81326     }
81327   }
81328
81329 }
81330
81331
81332 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFrictionCoefficient(void * jarg1) {
81333   float jresult ;
81334   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81335   float result;
81336
81337   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81338   {
81339     try {
81340       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFrictionCoefficient();
81341     } catch (std::out_of_range& e) {
81342       {
81343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81344       };
81345     } catch (std::exception& e) {
81346       {
81347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81348       };
81349     } catch (Dali::DaliException e) {
81350       {
81351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81352       };
81353     } catch (...) {
81354       {
81355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81356       };
81357     }
81358   }
81359
81360   jresult = result;
81361   return jresult;
81362 }
81363
81364
81365 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFrictionCoefficient(void * jarg1, float jarg2) {
81366   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81367   float arg2 ;
81368
81369   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81370   arg2 = (float)jarg2;
81371   {
81372     try {
81373       (arg1)->SetFrictionCoefficient(arg2);
81374     } catch (std::out_of_range& e) {
81375       {
81376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81377       };
81378     } catch (std::exception& e) {
81379       {
81380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81381       };
81382     } catch (Dali::DaliException e) {
81383       {
81384         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81385       };
81386     } catch (...) {
81387       {
81388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81389       };
81390     }
81391   }
81392
81393 }
81394
81395
81396 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFlickSpeedCoefficient(void * jarg1) {
81397   float jresult ;
81398   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81399   float result;
81400
81401   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81402   {
81403     try {
81404       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFlickSpeedCoefficient();
81405     } catch (std::out_of_range& e) {
81406       {
81407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81408       };
81409     } catch (std::exception& e) {
81410       {
81411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81412       };
81413     } catch (Dali::DaliException e) {
81414       {
81415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81416       };
81417     } catch (...) {
81418       {
81419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81420       };
81421     }
81422   }
81423
81424   jresult = result;
81425   return jresult;
81426 }
81427
81428
81429 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFlickSpeedCoefficient(void * jarg1, float jarg2) {
81430   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81431   float arg2 ;
81432
81433   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81434   arg2 = (float)jarg2;
81435   {
81436     try {
81437       (arg1)->SetFlickSpeedCoefficient(arg2);
81438     } catch (std::out_of_range& e) {
81439       {
81440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81441       };
81442     } catch (std::exception& e) {
81443       {
81444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81445       };
81446     } catch (Dali::DaliException e) {
81447       {
81448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81449       };
81450     } catch (...) {
81451       {
81452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81453       };
81454     }
81455   }
81456
81457 }
81458
81459
81460 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumDistanceForFlick(void * jarg1) {
81461   void * jresult ;
81462   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81463   Dali::Vector2 result;
81464
81465   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81466   {
81467     try {
81468       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumDistanceForFlick();
81469     } catch (std::out_of_range& e) {
81470       {
81471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81472       };
81473     } catch (std::exception& e) {
81474       {
81475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81476       };
81477     } catch (Dali::DaliException e) {
81478       {
81479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81480       };
81481     } catch (...) {
81482       {
81483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81484       };
81485     }
81486   }
81487
81488   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
81489   return jresult;
81490 }
81491
81492
81493 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumDistanceForFlick(void * jarg1, void * jarg2) {
81494   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81495   Dali::Vector2 *arg2 = 0 ;
81496
81497   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81498   arg2 = (Dali::Vector2 *)jarg2;
81499   if (!arg2) {
81500     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81501     return ;
81502   }
81503   {
81504     try {
81505       (arg1)->SetMinimumDistanceForFlick((Dali::Vector2 const &)*arg2);
81506     } catch (std::out_of_range& e) {
81507       {
81508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81509       };
81510     } catch (std::exception& e) {
81511       {
81512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81513       };
81514     } catch (Dali::DaliException e) {
81515       {
81516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81517       };
81518     } catch (...) {
81519       {
81520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81521       };
81522     }
81523   }
81524
81525 }
81526
81527
81528 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumSpeedForFlick(void * jarg1) {
81529   float jresult ;
81530   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81531   float result;
81532
81533   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81534   {
81535     try {
81536       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumSpeedForFlick();
81537     } catch (std::out_of_range& e) {
81538       {
81539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81540       };
81541     } catch (std::exception& e) {
81542       {
81543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81544       };
81545     } catch (Dali::DaliException e) {
81546       {
81547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81548       };
81549     } catch (...) {
81550       {
81551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81552       };
81553     }
81554   }
81555
81556   jresult = result;
81557   return jresult;
81558 }
81559
81560
81561 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumSpeedForFlick(void * jarg1, float jarg2) {
81562   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81563   float arg2 ;
81564
81565   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81566   arg2 = (float)jarg2;
81567   {
81568     try {
81569       (arg1)->SetMinimumSpeedForFlick(arg2);
81570     } catch (std::out_of_range& e) {
81571       {
81572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81573       };
81574     } catch (std::exception& e) {
81575       {
81576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81577       };
81578     } catch (Dali::DaliException e) {
81579       {
81580         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81581       };
81582     } catch (...) {
81583       {
81584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81585       };
81586     }
81587   }
81588
81589 }
81590
81591
81592 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMaxFlickSpeed(void * jarg1) {
81593   float jresult ;
81594   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81595   float result;
81596
81597   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81598   {
81599     try {
81600       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMaxFlickSpeed();
81601     } catch (std::out_of_range& e) {
81602       {
81603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81604       };
81605     } catch (std::exception& e) {
81606       {
81607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81608       };
81609     } catch (Dali::DaliException e) {
81610       {
81611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81612       };
81613     } catch (...) {
81614       {
81615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81616       };
81617     }
81618   }
81619
81620   jresult = result;
81621   return jresult;
81622 }
81623
81624
81625 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxFlickSpeed(void * jarg1, float jarg2) {
81626   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81627   float arg2 ;
81628
81629   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81630   arg2 = (float)jarg2;
81631   {
81632     try {
81633       (arg1)->SetMaxFlickSpeed(arg2);
81634     } catch (std::out_of_range& e) {
81635       {
81636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81637       };
81638     } catch (std::exception& e) {
81639       {
81640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81641       };
81642     } catch (Dali::DaliException e) {
81643       {
81644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81645       };
81646     } catch (...) {
81647       {
81648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81649       };
81650     }
81651   }
81652
81653 }
81654
81655
81656 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetWheelScrollDistanceStep(void * jarg1) {
81657   void * jresult ;
81658   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81659   Dali::Vector2 result;
81660
81661   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81662   {
81663     try {
81664       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetWheelScrollDistanceStep();
81665     } catch (std::out_of_range& e) {
81666       {
81667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81668       };
81669     } catch (std::exception& e) {
81670       {
81671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81672       };
81673     } catch (Dali::DaliException e) {
81674       {
81675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81676       };
81677     } catch (...) {
81678       {
81679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81680       };
81681     }
81682   }
81683
81684   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
81685   return jresult;
81686 }
81687
81688
81689 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWheelScrollDistanceStep(void * jarg1, void * jarg2) {
81690   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81691   Dali::Vector2 arg2 ;
81692   Dali::Vector2 *argp2 ;
81693
81694   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81695   argp2 = (Dali::Vector2 *)jarg2;
81696   if (!argp2) {
81697     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
81698     return ;
81699   }
81700   arg2 = *argp2;
81701   {
81702     try {
81703       (arg1)->SetWheelScrollDistanceStep(arg2);
81704     } catch (std::out_of_range& e) {
81705       {
81706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81707       };
81708     } catch (std::exception& e) {
81709       {
81710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81711       };
81712     } catch (Dali::DaliException e) {
81713       {
81714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81715       };
81716     } catch (...) {
81717       {
81718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81719       };
81720     }
81721   }
81722
81723 }
81724
81725
81726 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentScrollPosition(void * jarg1) {
81727   void * jresult ;
81728   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81729   Dali::Vector2 result;
81730
81731   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81732   {
81733     try {
81734       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentScrollPosition();
81735     } catch (std::out_of_range& e) {
81736       {
81737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81738       };
81739     } catch (std::exception& e) {
81740       {
81741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81742       };
81743     } catch (Dali::DaliException e) {
81744       {
81745         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81746       };
81747     } catch (...) {
81748       {
81749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81750       };
81751     }
81752   }
81753
81754   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
81755   return jresult;
81756 }
81757
81758
81759 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentPage(void * jarg1) {
81760   unsigned int jresult ;
81761   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81762   unsigned int result;
81763
81764   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81765   {
81766     try {
81767       result = (unsigned int)((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentPage();
81768     } catch (std::out_of_range& e) {
81769       {
81770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81771       };
81772     } catch (std::exception& e) {
81773       {
81774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81775       };
81776     } catch (Dali::DaliException e) {
81777       {
81778         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81779       };
81780     } catch (...) {
81781       {
81782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81783       };
81784     }
81785   }
81786
81787   jresult = result;
81788   return jresult;
81789 }
81790
81791
81792 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_0(void * jarg1, void * jarg2) {
81793   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81794   Dali::Vector2 *arg2 = 0 ;
81795
81796   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81797   arg2 = (Dali::Vector2 *)jarg2;
81798   if (!arg2) {
81799     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81800     return ;
81801   }
81802   {
81803     try {
81804       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2);
81805     } catch (std::out_of_range& e) {
81806       {
81807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81808       };
81809     } catch (std::exception& e) {
81810       {
81811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81812       };
81813     } catch (Dali::DaliException e) {
81814       {
81815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81816       };
81817     } catch (...) {
81818       {
81819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81820       };
81821     }
81822   }
81823
81824 }
81825
81826
81827 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
81828   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81829   Dali::Vector2 *arg2 = 0 ;
81830   float arg3 ;
81831
81832   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81833   arg2 = (Dali::Vector2 *)jarg2;
81834   if (!arg2) {
81835     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81836     return ;
81837   }
81838   arg3 = (float)jarg3;
81839   {
81840     try {
81841       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3);
81842     } catch (std::out_of_range& e) {
81843       {
81844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81845       };
81846     } catch (std::exception& e) {
81847       {
81848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81849       };
81850     } catch (Dali::DaliException e) {
81851       {
81852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81853       };
81854     } catch (...) {
81855       {
81856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81857       };
81858     }
81859   }
81860
81861 }
81862
81863
81864 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_2(void * jarg1, void * jarg2, float jarg3, void * jarg4) {
81865   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81866   Dali::Vector2 *arg2 = 0 ;
81867   float arg3 ;
81868   Dali::AlphaFunction arg4 ;
81869   Dali::AlphaFunction *argp4 ;
81870
81871   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81872   arg2 = (Dali::Vector2 *)jarg2;
81873   if (!arg2) {
81874     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81875     return ;
81876   }
81877   arg3 = (float)jarg3;
81878   argp4 = (Dali::AlphaFunction *)jarg4;
81879   if (!argp4) {
81880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
81881     return ;
81882   }
81883   arg4 = *argp4;
81884   {
81885     try {
81886       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4);
81887     } catch (std::out_of_range& e) {
81888       {
81889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81890       };
81891     } catch (std::exception& e) {
81892       {
81893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81894       };
81895     } catch (Dali::DaliException e) {
81896       {
81897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81898       };
81899     } catch (...) {
81900       {
81901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81902       };
81903     }
81904   }
81905
81906 }
81907
81908
81909 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_3(void * jarg1, void * jarg2, float jarg3, int jarg4, int jarg5) {
81910   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81911   Dali::Vector2 *arg2 = 0 ;
81912   float arg3 ;
81913   Dali::Toolkit::DirectionBias arg4 ;
81914   Dali::Toolkit::DirectionBias arg5 ;
81915
81916   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81917   arg2 = (Dali::Vector2 *)jarg2;
81918   if (!arg2) {
81919     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81920     return ;
81921   }
81922   arg3 = (float)jarg3;
81923   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
81924   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
81925   {
81926     try {
81927       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5);
81928     } catch (std::out_of_range& e) {
81929       {
81930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81931       };
81932     } catch (std::exception& e) {
81933       {
81934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81935       };
81936     } catch (Dali::DaliException e) {
81937       {
81938         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81939       };
81940     } catch (...) {
81941       {
81942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81943       };
81944     }
81945   }
81946
81947 }
81948
81949
81950 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_4(void * jarg1, void * jarg2, float jarg3, void * jarg4, int jarg5, int jarg6) {
81951   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81952   Dali::Vector2 *arg2 = 0 ;
81953   float arg3 ;
81954   Dali::AlphaFunction arg4 ;
81955   Dali::Toolkit::DirectionBias arg5 ;
81956   Dali::Toolkit::DirectionBias arg6 ;
81957   Dali::AlphaFunction *argp4 ;
81958
81959   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81960   arg2 = (Dali::Vector2 *)jarg2;
81961   if (!arg2) {
81962     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81963     return ;
81964   }
81965   arg3 = (float)jarg3;
81966   argp4 = (Dali::AlphaFunction *)jarg4;
81967   if (!argp4) {
81968     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
81969     return ;
81970   }
81971   arg4 = *argp4;
81972   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
81973   arg6 = (Dali::Toolkit::DirectionBias)jarg6;
81974   {
81975     try {
81976       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5,arg6);
81977     } catch (std::out_of_range& e) {
81978       {
81979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81980       };
81981     } catch (std::exception& e) {
81982       {
81983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81984       };
81985     } catch (Dali::DaliException e) {
81986       {
81987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81988       };
81989     } catch (...) {
81990       {
81991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81992       };
81993     }
81994   }
81995
81996 }
81997
81998
81999 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_5(void * jarg1, unsigned int jarg2) {
82000   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82001   unsigned int arg2 ;
82002
82003   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82004   arg2 = (unsigned int)jarg2;
82005   {
82006     try {
82007       (arg1)->ScrollTo(arg2);
82008     } catch (std::out_of_range& e) {
82009       {
82010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82011       };
82012     } catch (std::exception& e) {
82013       {
82014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82015       };
82016     } catch (Dali::DaliException e) {
82017       {
82018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82019       };
82020     } catch (...) {
82021       {
82022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82023       };
82024     }
82025   }
82026
82027 }
82028
82029
82030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_6(void * jarg1, unsigned int jarg2, float jarg3) {
82031   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82032   unsigned int arg2 ;
82033   float arg3 ;
82034
82035   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82036   arg2 = (unsigned int)jarg2;
82037   arg3 = (float)jarg3;
82038   {
82039     try {
82040       (arg1)->ScrollTo(arg2,arg3);
82041     } catch (std::out_of_range& e) {
82042       {
82043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82044       };
82045     } catch (std::exception& e) {
82046       {
82047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82048       };
82049     } catch (Dali::DaliException e) {
82050       {
82051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82052       };
82053     } catch (...) {
82054       {
82055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82056       };
82057     }
82058   }
82059
82060 }
82061
82062
82063 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_7(void * jarg1, unsigned int jarg2, float jarg3, int jarg4) {
82064   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82065   unsigned int arg2 ;
82066   float arg3 ;
82067   Dali::Toolkit::DirectionBias arg4 ;
82068
82069   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82070   arg2 = (unsigned int)jarg2;
82071   arg3 = (float)jarg3;
82072   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
82073   {
82074     try {
82075       (arg1)->ScrollTo(arg2,arg3,arg4);
82076     } catch (std::out_of_range& e) {
82077       {
82078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82079       };
82080     } catch (std::exception& e) {
82081       {
82082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82083       };
82084     } catch (Dali::DaliException e) {
82085       {
82086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82087       };
82088     } catch (...) {
82089       {
82090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82091       };
82092     }
82093   }
82094
82095 }
82096
82097
82098 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_8(void * jarg1, void * jarg2) {
82099   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82100   Dali::Actor *arg2 = 0 ;
82101
82102   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82103   arg2 = (Dali::Actor *)jarg2;
82104   if (!arg2) {
82105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
82106     return ;
82107   }
82108   {
82109     try {
82110       (arg1)->ScrollTo(*arg2);
82111     } catch (std::out_of_range& e) {
82112       {
82113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82114       };
82115     } catch (std::exception& e) {
82116       {
82117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82118       };
82119     } catch (Dali::DaliException e) {
82120       {
82121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82122       };
82123     } catch (...) {
82124       {
82125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82126       };
82127     }
82128   }
82129
82130 }
82131
82132
82133 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_9(void * jarg1, void * jarg2, float jarg3) {
82134   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82135   Dali::Actor *arg2 = 0 ;
82136   float arg3 ;
82137
82138   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82139   arg2 = (Dali::Actor *)jarg2;
82140   if (!arg2) {
82141     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
82142     return ;
82143   }
82144   arg3 = (float)jarg3;
82145   {
82146     try {
82147       (arg1)->ScrollTo(*arg2,arg3);
82148     } catch (std::out_of_range& e) {
82149       {
82150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82151       };
82152     } catch (std::exception& e) {
82153       {
82154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82155       };
82156     } catch (Dali::DaliException e) {
82157       {
82158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82159       };
82160     } catch (...) {
82161       {
82162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82163       };
82164     }
82165   }
82166
82167 }
82168
82169
82170 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_ScrollToSnapPoint(void * jarg1) {
82171   unsigned int jresult ;
82172   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82173   bool result;
82174
82175   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82176   {
82177     try {
82178       result = (bool)(arg1)->ScrollToSnapPoint();
82179     } catch (std::out_of_range& e) {
82180       {
82181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82182       };
82183     } catch (std::exception& e) {
82184       {
82185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82186       };
82187     } catch (Dali::DaliException e) {
82188       {
82189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82190       };
82191     } catch (...) {
82192       {
82193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82194       };
82195     }
82196   }
82197
82198   jresult = result;
82199   return jresult;
82200 }
82201
82202
82203 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyConstraintToChildren(void * jarg1, void * jarg2) {
82204   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82205   Dali::Constraint arg2 ;
82206   Dali::Constraint *argp2 ;
82207
82208   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82209   argp2 = (Dali::Constraint *)jarg2;
82210   if (!argp2) {
82211     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Constraint", 0);
82212     return ;
82213   }
82214   arg2 = *argp2;
82215   {
82216     try {
82217       (arg1)->ApplyConstraintToChildren(arg2);
82218     } catch (std::out_of_range& e) {
82219       {
82220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82221       };
82222     } catch (std::exception& e) {
82223       {
82224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82225       };
82226     } catch (Dali::DaliException e) {
82227       {
82228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82229       };
82230     } catch (...) {
82231       {
82232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82233       };
82234     }
82235   }
82236
82237 }
82238
82239
82240 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveConstraintsFromChildren(void * jarg1) {
82241   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82242
82243   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82244   {
82245     try {
82246       (arg1)->RemoveConstraintsFromChildren();
82247     } catch (std::out_of_range& e) {
82248       {
82249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82250       };
82251     } catch (std::exception& e) {
82252       {
82253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82254       };
82255     } catch (Dali::DaliException e) {
82256       {
82257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82258       };
82259     } catch (...) {
82260       {
82261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82262       };
82263     }
82264   }
82265
82266 }
82267
82268
82269 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyEffect(void * jarg1, void * jarg2) {
82270   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82271   Dali::Toolkit::ScrollViewEffect arg2 ;
82272   Dali::Toolkit::ScrollViewEffect *argp2 ;
82273
82274   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82275   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
82276   if (!argp2) {
82277     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
82278     return ;
82279   }
82280   arg2 = *argp2;
82281   {
82282     try {
82283       (arg1)->ApplyEffect(arg2);
82284     } catch (std::out_of_range& e) {
82285       {
82286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82287       };
82288     } catch (std::exception& e) {
82289       {
82290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82291       };
82292     } catch (Dali::DaliException e) {
82293       {
82294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82295       };
82296     } catch (...) {
82297       {
82298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82299       };
82300     }
82301   }
82302
82303 }
82304
82305
82306 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveEffect(void * jarg1, void * jarg2) {
82307   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82308   Dali::Toolkit::ScrollViewEffect arg2 ;
82309   Dali::Toolkit::ScrollViewEffect *argp2 ;
82310
82311   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82312   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
82313   if (!argp2) {
82314     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
82315     return ;
82316   }
82317   arg2 = *argp2;
82318   {
82319     try {
82320       (arg1)->RemoveEffect(arg2);
82321     } catch (std::out_of_range& e) {
82322       {
82323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82324       };
82325     } catch (std::exception& e) {
82326       {
82327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82328       };
82329     } catch (Dali::DaliException e) {
82330       {
82331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82332       };
82333     } catch (...) {
82334       {
82335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82336       };
82337     }
82338   }
82339
82340 }
82341
82342
82343 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveAllEffects(void * jarg1) {
82344   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82345
82346   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82347   {
82348     try {
82349       (arg1)->RemoveAllEffects();
82350     } catch (std::out_of_range& e) {
82351       {
82352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82353       };
82354     } catch (std::exception& e) {
82355       {
82356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82357       };
82358     } catch (Dali::DaliException e) {
82359       {
82360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82361       };
82362     } catch (...) {
82363       {
82364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82365       };
82366     }
82367   }
82368
82369 }
82370
82371
82372 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_BindActor(void * jarg1, void * jarg2) {
82373   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82374   Dali::Actor arg2 ;
82375   Dali::Actor *argp2 ;
82376
82377   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82378   argp2 = (Dali::Actor *)jarg2;
82379   if (!argp2) {
82380     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82381     return ;
82382   }
82383   arg2 = *argp2;
82384   {
82385     try {
82386       (arg1)->BindActor(arg2);
82387     } catch (std::out_of_range& e) {
82388       {
82389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82390       };
82391     } catch (std::exception& e) {
82392       {
82393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82394       };
82395     } catch (Dali::DaliException e) {
82396       {
82397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82398       };
82399     } catch (...) {
82400       {
82401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82402       };
82403     }
82404   }
82405
82406 }
82407
82408
82409 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_UnbindActor(void * jarg1, void * jarg2) {
82410   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82411   Dali::Actor arg2 ;
82412   Dali::Actor *argp2 ;
82413
82414   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82415   argp2 = (Dali::Actor *)jarg2;
82416   if (!argp2) {
82417     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82418     return ;
82419   }
82420   arg2 = *argp2;
82421   {
82422     try {
82423       (arg1)->UnbindActor(arg2);
82424     } catch (std::out_of_range& e) {
82425       {
82426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82427       };
82428     } catch (std::exception& e) {
82429       {
82430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82431       };
82432     } catch (Dali::DaliException e) {
82433       {
82434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82435       };
82436     } catch (...) {
82437       {
82438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82439       };
82440     }
82441   }
82442
82443 }
82444
82445
82446 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
82447   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82448   Dali::Radian arg2 ;
82449   Dali::Radian arg3 ;
82450   Dali::Radian *argp2 ;
82451   Dali::Radian *argp3 ;
82452
82453   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82454   argp2 = (Dali::Radian *)jarg2;
82455   if (!argp2) {
82456     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
82457     return ;
82458   }
82459   arg2 = *argp2;
82460   argp3 = (Dali::Radian *)jarg3;
82461   if (!argp3) {
82462     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
82463     return ;
82464   }
82465   arg3 = *argp3;
82466   {
82467     try {
82468       (arg1)->SetScrollingDirection(arg2,arg3);
82469     } catch (std::out_of_range& e) {
82470       {
82471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82472       };
82473     } catch (std::exception& e) {
82474       {
82475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82476       };
82477     } catch (Dali::DaliException e) {
82478       {
82479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82480       };
82481     } catch (...) {
82482       {
82483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82484       };
82485     }
82486   }
82487
82488 }
82489
82490
82491 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_1(void * jarg1, void * jarg2) {
82492   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82493   Dali::Radian arg2 ;
82494   Dali::Radian *argp2 ;
82495
82496   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82497   argp2 = (Dali::Radian *)jarg2;
82498   if (!argp2) {
82499     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
82500     return ;
82501   }
82502   arg2 = *argp2;
82503   {
82504     try {
82505       (arg1)->SetScrollingDirection(arg2);
82506     } catch (std::out_of_range& e) {
82507       {
82508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82509       };
82510     } catch (std::exception& e) {
82511       {
82512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82513       };
82514     } catch (Dali::DaliException e) {
82515       {
82516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82517       };
82518     } catch (...) {
82519       {
82520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82521       };
82522     }
82523   }
82524
82525 }
82526
82527
82528 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveScrollingDirection(void * jarg1, void * jarg2) {
82529   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82530   Dali::Radian arg2 ;
82531   Dali::Radian *argp2 ;
82532
82533   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82534   argp2 = (Dali::Radian *)jarg2;
82535   if (!argp2) {
82536     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
82537     return ;
82538   }
82539   arg2 = *argp2;
82540   {
82541     try {
82542       (arg1)->RemoveScrollingDirection(arg2);
82543     } catch (std::out_of_range& e) {
82544       {
82545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82546       };
82547     } catch (std::exception& e) {
82548       {
82549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82550       };
82551     } catch (Dali::DaliException e) {
82552       {
82553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82554       };
82555     } catch (...) {
82556       {
82557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82558       };
82559     }
82560   }
82561
82562 }
82563
82564
82565 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapStartedSignal(void * jarg1) {
82566   void * jresult ;
82567   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82568   Dali::Toolkit::ScrollView::SnapStartedSignalType *result = 0 ;
82569
82570   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82571   {
82572     try {
82573       result = (Dali::Toolkit::ScrollView::SnapStartedSignalType *) &(arg1)->SnapStartedSignal();
82574     } catch (std::out_of_range& e) {
82575       {
82576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82577       };
82578     } catch (std::exception& e) {
82579       {
82580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82581       };
82582     } catch (Dali::DaliException e) {
82583       {
82584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82585       };
82586     } catch (...) {
82587       {
82588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82589       };
82590     }
82591   }
82592
82593   jresult = (void *)result;
82594   return jresult;
82595 }
82596
82597
82598 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_ROWS_get() {
82599   int jresult ;
82600   int result;
82601
82602   result = (int)Dali::Toolkit::TableView::Property::ROWS;
82603   jresult = (int)result;
82604   return jresult;
82605 }
82606
82607
82608 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_COLUMNS_get() {
82609   int jresult ;
82610   int result;
82611
82612   result = (int)Dali::Toolkit::TableView::Property::COLUMNS;
82613   jresult = (int)result;
82614   return jresult;
82615 }
82616
82617
82618 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_CELL_PADDING_get() {
82619   int jresult ;
82620   int result;
82621
82622   result = (int)Dali::Toolkit::TableView::Property::CELL_PADDING;
82623   jresult = (int)result;
82624   return jresult;
82625 }
82626
82627
82628 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_ROWS_get() {
82629   int jresult ;
82630   int result;
82631
82632   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_ROWS;
82633   jresult = (int)result;
82634   return jresult;
82635 }
82636
82637
82638 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_COLUMNS_get() {
82639   int jresult ;
82640   int result;
82641
82642   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_COLUMNS;
82643   jresult = (int)result;
82644   return jresult;
82645 }
82646
82647
82648 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_Property() {
82649   void * jresult ;
82650   Dali::Toolkit::TableView::Property *result = 0 ;
82651
82652   {
82653     try {
82654       result = (Dali::Toolkit::TableView::Property *)new Dali::Toolkit::TableView::Property();
82655     } catch (std::out_of_range& e) {
82656       {
82657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82658       };
82659     } catch (std::exception& e) {
82660       {
82661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82662       };
82663     } catch (Dali::DaliException e) {
82664       {
82665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82666       };
82667     } catch (...) {
82668       {
82669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82670       };
82671     }
82672   }
82673
82674   jresult = (void *)result;
82675   return jresult;
82676 }
82677
82678
82679 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_Property(void * jarg1) {
82680   Dali::Toolkit::TableView::Property *arg1 = (Dali::Toolkit::TableView::Property *) 0 ;
82681
82682   arg1 = (Dali::Toolkit::TableView::Property *)jarg1;
82683   {
82684     try {
82685       delete arg1;
82686     } catch (std::out_of_range& e) {
82687       {
82688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82689       };
82690     } catch (std::exception& e) {
82691       {
82692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82693       };
82694     } catch (Dali::DaliException e) {
82695       {
82696         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82697       };
82698     } catch (...) {
82699       {
82700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82701       };
82702     }
82703   }
82704
82705 }
82706
82707
82708 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_INDEX_get() {
82709   int jresult ;
82710   int result;
82711
82712   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_INDEX;
82713   jresult = (int)result;
82714   return jresult;
82715 }
82716
82717
82718 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_ROW_SPAN_get() {
82719   int jresult ;
82720   int result;
82721
82722   result = (int)Dali::Toolkit::TableView::ChildProperty::ROW_SPAN;
82723   jresult = (int)result;
82724   return jresult;
82725 }
82726
82727
82728 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_COLUMN_SPAN_get() {
82729   int jresult ;
82730   int result;
82731
82732   result = (int)Dali::Toolkit::TableView::ChildProperty::COLUMN_SPAN;
82733   jresult = (int)result;
82734   return jresult;
82735 }
82736
82737
82738 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_HORIZONTAL_ALIGNMENT_get() {
82739   int jresult ;
82740   int result;
82741
82742   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_HORIZONTAL_ALIGNMENT;
82743   jresult = (int)result;
82744   return jresult;
82745 }
82746
82747
82748 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_VERTICAL_ALIGNMENT_get() {
82749   int jresult ;
82750   int result;
82751
82752   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_VERTICAL_ALIGNMENT;
82753   jresult = (int)result;
82754   return jresult;
82755 }
82756
82757
82758 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_ChildProperty() {
82759   void * jresult ;
82760   Dali::Toolkit::TableView::ChildProperty *result = 0 ;
82761
82762   {
82763     try {
82764       result = (Dali::Toolkit::TableView::ChildProperty *)new Dali::Toolkit::TableView::ChildProperty();
82765     } catch (std::out_of_range& e) {
82766       {
82767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82768       };
82769     } catch (std::exception& e) {
82770       {
82771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82772       };
82773     } catch (Dali::DaliException e) {
82774       {
82775         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82776       };
82777     } catch (...) {
82778       {
82779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82780       };
82781     }
82782   }
82783
82784   jresult = (void *)result;
82785   return jresult;
82786 }
82787
82788
82789 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_ChildProperty(void * jarg1) {
82790   Dali::Toolkit::TableView::ChildProperty *arg1 = (Dali::Toolkit::TableView::ChildProperty *) 0 ;
82791
82792   arg1 = (Dali::Toolkit::TableView::ChildProperty *)jarg1;
82793   {
82794     try {
82795       delete arg1;
82796     } catch (std::out_of_range& e) {
82797       {
82798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82799       };
82800     } catch (std::exception& e) {
82801       {
82802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82803       };
82804     } catch (Dali::DaliException e) {
82805       {
82806         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82807       };
82808     } catch (...) {
82809       {
82810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82811       };
82812     }
82813   }
82814
82815 }
82816
82817
82818 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_0(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) {
82819   void * jresult ;
82820   unsigned int arg1 ;
82821   unsigned int arg2 ;
82822   unsigned int arg3 ;
82823   unsigned int arg4 ;
82824   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82825
82826   arg1 = (unsigned int)jarg1;
82827   arg2 = (unsigned int)jarg2;
82828   arg3 = (unsigned int)jarg3;
82829   arg4 = (unsigned int)jarg4;
82830   {
82831     try {
82832       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3,arg4);
82833     } catch (std::out_of_range& e) {
82834       {
82835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82836       };
82837     } catch (std::exception& e) {
82838       {
82839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82840       };
82841     } catch (Dali::DaliException e) {
82842       {
82843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82844       };
82845     } catch (...) {
82846       {
82847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82848       };
82849     }
82850   }
82851
82852   jresult = (void *)result;
82853   return jresult;
82854 }
82855
82856
82857 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_1(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
82858   void * jresult ;
82859   unsigned int arg1 ;
82860   unsigned int arg2 ;
82861   unsigned int arg3 ;
82862   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82863
82864   arg1 = (unsigned int)jarg1;
82865   arg2 = (unsigned int)jarg2;
82866   arg3 = (unsigned int)jarg3;
82867   {
82868     try {
82869       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3);
82870     } catch (std::out_of_range& e) {
82871       {
82872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82873       };
82874     } catch (std::exception& e) {
82875       {
82876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82877       };
82878     } catch (Dali::DaliException e) {
82879       {
82880         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82881       };
82882     } catch (...) {
82883       {
82884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82885       };
82886     }
82887   }
82888
82889   jresult = (void *)result;
82890   return jresult;
82891 }
82892
82893
82894 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
82895   void * jresult ;
82896   unsigned int arg1 ;
82897   unsigned int arg2 ;
82898   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82899
82900   arg1 = (unsigned int)jarg1;
82901   arg2 = (unsigned int)jarg2;
82902   {
82903     try {
82904       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2);
82905     } catch (std::out_of_range& e) {
82906       {
82907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82908       };
82909     } catch (std::exception& e) {
82910       {
82911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82912       };
82913     } catch (Dali::DaliException e) {
82914       {
82915         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82916       };
82917     } catch (...) {
82918       {
82919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82920       };
82921     }
82922   }
82923
82924   jresult = (void *)result;
82925   return jresult;
82926 }
82927
82928
82929 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_3(unsigned int jarg1) {
82930   void * jresult ;
82931   unsigned int arg1 ;
82932   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82933
82934   arg1 = (unsigned int)jarg1;
82935   {
82936     try {
82937       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1);
82938     } catch (std::out_of_range& e) {
82939       {
82940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82941       };
82942     } catch (std::exception& e) {
82943       {
82944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82945       };
82946     } catch (Dali::DaliException e) {
82947       {
82948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82949       };
82950     } catch (...) {
82951       {
82952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82953       };
82954     }
82955   }
82956
82957   jresult = (void *)result;
82958   return jresult;
82959 }
82960
82961
82962 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_4() {
82963   void * jresult ;
82964   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82965
82966   {
82967     try {
82968       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition();
82969     } catch (std::out_of_range& e) {
82970       {
82971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82972       };
82973     } catch (std::exception& e) {
82974       {
82975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82976       };
82977     } catch (Dali::DaliException e) {
82978       {
82979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82980       };
82981     } catch (...) {
82982       {
82983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82984       };
82985     }
82986   }
82987
82988   jresult = (void *)result;
82989   return jresult;
82990 }
82991
82992
82993 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_set(void * jarg1, unsigned int jarg2) {
82994   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82995   unsigned int arg2 ;
82996
82997   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82998   arg2 = (unsigned int)jarg2;
82999   if (arg1) (arg1)->rowIndex = arg2;
83000 }
83001
83002
83003 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_get(void * jarg1) {
83004   unsigned int jresult ;
83005   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
83006   unsigned int result;
83007
83008   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
83009   result = (unsigned int) ((arg1)->rowIndex);
83010   jresult = result;
83011   return jresult;
83012 }
83013
83014
83015 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_set(void * jarg1, unsigned int jarg2) {
83016   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
83017   unsigned int arg2 ;
83018
83019   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
83020   arg2 = (unsigned int)jarg2;
83021   if (arg1) (arg1)->columnIndex = arg2;
83022 }
83023
83024
83025 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_get(void * jarg1) {
83026   unsigned int jresult ;
83027   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
83028   unsigned int result;
83029
83030   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
83031   result = (unsigned int) ((arg1)->columnIndex);
83032   jresult = result;
83033   return jresult;
83034 }
83035
83036
83037 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_set(void * jarg1, unsigned int jarg2) {
83038   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
83039   unsigned int arg2 ;
83040
83041   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
83042   arg2 = (unsigned int)jarg2;
83043   if (arg1) (arg1)->rowSpan = arg2;
83044 }
83045
83046
83047 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_get(void * jarg1) {
83048   unsigned int jresult ;
83049   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
83050   unsigned int result;
83051
83052   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
83053   result = (unsigned int) ((arg1)->rowSpan);
83054   jresult = result;
83055   return jresult;
83056 }
83057
83058
83059 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_set(void * jarg1, unsigned int jarg2) {
83060   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
83061   unsigned int arg2 ;
83062
83063   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
83064   arg2 = (unsigned int)jarg2;
83065   if (arg1) (arg1)->columnSpan = arg2;
83066 }
83067
83068
83069 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_get(void * jarg1) {
83070   unsigned int jresult ;
83071   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
83072   unsigned int result;
83073
83074   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
83075   result = (unsigned int) ((arg1)->columnSpan);
83076   jresult = result;
83077   return jresult;
83078 }
83079
83080
83081 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_CellPosition(void * jarg1) {
83082   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
83083
83084   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
83085   {
83086     try {
83087       delete arg1;
83088     } catch (std::out_of_range& e) {
83089       {
83090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83091       };
83092     } catch (std::exception& e) {
83093       {
83094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83095       };
83096     } catch (Dali::DaliException e) {
83097       {
83098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83099       };
83100     } catch (...) {
83101       {
83102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83103       };
83104     }
83105   }
83106
83107 }
83108
83109
83110 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_0() {
83111   void * jresult ;
83112   Dali::Toolkit::TableView *result = 0 ;
83113
83114   {
83115     try {
83116       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView();
83117     } catch (std::out_of_range& e) {
83118       {
83119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83120       };
83121     } catch (std::exception& e) {
83122       {
83123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83124       };
83125     } catch (Dali::DaliException e) {
83126       {
83127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83128       };
83129     } catch (...) {
83130       {
83131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83132       };
83133     }
83134   }
83135
83136   jresult = (void *)result;
83137   return jresult;
83138 }
83139
83140
83141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_1(void * jarg1) {
83142   void * jresult ;
83143   Dali::Toolkit::TableView *arg1 = 0 ;
83144   Dali::Toolkit::TableView *result = 0 ;
83145
83146   arg1 = (Dali::Toolkit::TableView *)jarg1;
83147   if (!arg1) {
83148     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
83149     return 0;
83150   }
83151   {
83152     try {
83153       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView((Dali::Toolkit::TableView const &)*arg1);
83154     } catch (std::out_of_range& e) {
83155       {
83156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83157       };
83158     } catch (std::exception& e) {
83159       {
83160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83161       };
83162     } catch (Dali::DaliException e) {
83163       {
83164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83165       };
83166     } catch (...) {
83167       {
83168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83169       };
83170     }
83171   }
83172
83173   jresult = (void *)result;
83174   return jresult;
83175 }
83176
83177
83178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_Assign(void * jarg1, void * jarg2) {
83179   void * jresult ;
83180   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83181   Dali::Toolkit::TableView *arg2 = 0 ;
83182   Dali::Toolkit::TableView *result = 0 ;
83183
83184   arg1 = (Dali::Toolkit::TableView *)jarg1;
83185   arg2 = (Dali::Toolkit::TableView *)jarg2;
83186   if (!arg2) {
83187     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
83188     return 0;
83189   }
83190   {
83191     try {
83192       result = (Dali::Toolkit::TableView *) &(arg1)->operator =((Dali::Toolkit::TableView const &)*arg2);
83193     } catch (std::out_of_range& e) {
83194       {
83195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83196       };
83197     } catch (std::exception& e) {
83198       {
83199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83200       };
83201     } catch (Dali::DaliException e) {
83202       {
83203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83204       };
83205     } catch (...) {
83206       {
83207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83208       };
83209     }
83210   }
83211
83212   jresult = (void *)result;
83213   return jresult;
83214 }
83215
83216
83217 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView(void * jarg1) {
83218   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83219
83220   arg1 = (Dali::Toolkit::TableView *)jarg1;
83221   {
83222     try {
83223       delete arg1;
83224     } catch (std::out_of_range& e) {
83225       {
83226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83227       };
83228     } catch (std::exception& e) {
83229       {
83230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83231       };
83232     } catch (Dali::DaliException e) {
83233       {
83234         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83235       };
83236     } catch (...) {
83237       {
83238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83239       };
83240     }
83241   }
83242
83243 }
83244
83245
83246 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_New(unsigned int jarg1, unsigned int jarg2) {
83247   void * jresult ;
83248   unsigned int arg1 ;
83249   unsigned int arg2 ;
83250   Dali::Toolkit::TableView result;
83251
83252   arg1 = (unsigned int)jarg1;
83253   arg2 = (unsigned int)jarg2;
83254   {
83255     try {
83256       result = Dali::Toolkit::TableView::New(arg1,arg2);
83257     } catch (std::out_of_range& e) {
83258       {
83259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83260       };
83261     } catch (std::exception& e) {
83262       {
83263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83264       };
83265     } catch (Dali::DaliException e) {
83266       {
83267         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83268       };
83269     } catch (...) {
83270       {
83271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83272       };
83273     }
83274   }
83275
83276   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
83277   return jresult;
83278 }
83279
83280
83281 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_DownCast(void * jarg1) {
83282   void * jresult ;
83283   Dali::BaseHandle arg1 ;
83284   Dali::BaseHandle *argp1 ;
83285   Dali::Toolkit::TableView result;
83286
83287   argp1 = (Dali::BaseHandle *)jarg1;
83288   if (!argp1) {
83289     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
83290     return 0;
83291   }
83292   arg1 = *argp1;
83293   {
83294     try {
83295       result = Dali::Toolkit::TableView::DownCast(arg1);
83296     } catch (std::out_of_range& e) {
83297       {
83298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83299       };
83300     } catch (std::exception& e) {
83301       {
83302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83303       };
83304     } catch (Dali::DaliException e) {
83305       {
83306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83307       };
83308     } catch (...) {
83309       {
83310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83311       };
83312     }
83313   }
83314
83315   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
83316   return jresult;
83317 }
83318
83319
83320 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_AddChild(void * jarg1, void * jarg2, void * jarg3) {
83321   unsigned int jresult ;
83322   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83323   Dali::Actor arg2 ;
83324   Dali::Toolkit::TableView::CellPosition arg3 ;
83325   Dali::Actor *argp2 ;
83326   Dali::Toolkit::TableView::CellPosition *argp3 ;
83327   bool result;
83328
83329   arg1 = (Dali::Toolkit::TableView *)jarg1;
83330   argp2 = (Dali::Actor *)jarg2;
83331   if (!argp2) {
83332     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83333     return 0;
83334   }
83335   arg2 = *argp2;
83336   argp3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
83337   if (!argp3) {
83338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
83339     return 0;
83340   }
83341   arg3 = *argp3;
83342   {
83343     try {
83344       result = (bool)(arg1)->AddChild(arg2,arg3);
83345     } catch (std::out_of_range& e) {
83346       {
83347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83348       };
83349     } catch (std::exception& e) {
83350       {
83351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83352       };
83353     } catch (Dali::DaliException e) {
83354       {
83355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83356       };
83357     } catch (...) {
83358       {
83359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83360       };
83361     }
83362   }
83363
83364   jresult = result;
83365   return jresult;
83366 }
83367
83368
83369 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetChildAt(void * jarg1, void * jarg2) {
83370   void * jresult ;
83371   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83372   Dali::Toolkit::TableView::CellPosition arg2 ;
83373   Dali::Toolkit::TableView::CellPosition *argp2 ;
83374   Dali::Actor result;
83375
83376   arg1 = (Dali::Toolkit::TableView *)jarg1;
83377   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
83378   if (!argp2) {
83379     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
83380     return 0;
83381   }
83382   arg2 = *argp2;
83383   {
83384     try {
83385       result = (arg1)->GetChildAt(arg2);
83386     } catch (std::out_of_range& e) {
83387       {
83388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83389       };
83390     } catch (std::exception& e) {
83391       {
83392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83393       };
83394     } catch (Dali::DaliException e) {
83395       {
83396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83397       };
83398     } catch (...) {
83399       {
83400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83401       };
83402     }
83403   }
83404
83405   jresult = new Dali::Actor((const Dali::Actor &)result);
83406   return jresult;
83407 }
83408
83409
83410 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_RemoveChildAt(void * jarg1, void * jarg2) {
83411   void * jresult ;
83412   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83413   Dali::Toolkit::TableView::CellPosition arg2 ;
83414   Dali::Toolkit::TableView::CellPosition *argp2 ;
83415   Dali::Actor result;
83416
83417   arg1 = (Dali::Toolkit::TableView *)jarg1;
83418   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
83419   if (!argp2) {
83420     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
83421     return 0;
83422   }
83423   arg2 = *argp2;
83424   {
83425     try {
83426       result = (arg1)->RemoveChildAt(arg2);
83427     } catch (std::out_of_range& e) {
83428       {
83429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83430       };
83431     } catch (std::exception& e) {
83432       {
83433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83434       };
83435     } catch (Dali::DaliException e) {
83436       {
83437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83438       };
83439     } catch (...) {
83440       {
83441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83442       };
83443     }
83444   }
83445
83446   jresult = new Dali::Actor((const Dali::Actor &)result);
83447   return jresult;
83448 }
83449
83450
83451 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_FindChildPosition(void * jarg1, void * jarg2, void * jarg3) {
83452   unsigned int jresult ;
83453   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83454   Dali::Actor arg2 ;
83455   Dali::Toolkit::TableView::CellPosition *arg3 = 0 ;
83456   Dali::Actor *argp2 ;
83457   bool result;
83458
83459   arg1 = (Dali::Toolkit::TableView *)jarg1;
83460   argp2 = (Dali::Actor *)jarg2;
83461   if (!argp2) {
83462     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83463     return 0;
83464   }
83465   arg2 = *argp2;
83466   arg3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
83467   if (!arg3) {
83468     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView::CellPosition & type is null", 0);
83469     return 0;
83470   }
83471   {
83472     try {
83473       result = (bool)(arg1)->FindChildPosition(arg2,*arg3);
83474     } catch (std::out_of_range& e) {
83475       {
83476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83477       };
83478     } catch (std::exception& e) {
83479       {
83480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83481       };
83482     } catch (Dali::DaliException e) {
83483       {
83484         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83485       };
83486     } catch (...) {
83487       {
83488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83489       };
83490     }
83491   }
83492
83493   jresult = result;
83494   return jresult;
83495 }
83496
83497
83498 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertRow(void * jarg1, unsigned int jarg2) {
83499   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83500   unsigned int arg2 ;
83501
83502   arg1 = (Dali::Toolkit::TableView *)jarg1;
83503   arg2 = (unsigned int)jarg2;
83504   {
83505     try {
83506       (arg1)->InsertRow(arg2);
83507     } catch (std::out_of_range& e) {
83508       {
83509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83510       };
83511     } catch (std::exception& e) {
83512       {
83513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83514       };
83515     } catch (Dali::DaliException e) {
83516       {
83517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83518       };
83519     } catch (...) {
83520       {
83521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83522       };
83523     }
83524   }
83525
83526 }
83527
83528
83529 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_0(void * jarg1, unsigned int jarg2) {
83530   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83531   unsigned int arg2 ;
83532
83533   arg1 = (Dali::Toolkit::TableView *)jarg1;
83534   arg2 = (unsigned int)jarg2;
83535   {
83536     try {
83537       (arg1)->DeleteRow(arg2);
83538     } catch (std::out_of_range& e) {
83539       {
83540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83541       };
83542     } catch (std::exception& e) {
83543       {
83544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83545       };
83546     } catch (Dali::DaliException e) {
83547       {
83548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83549       };
83550     } catch (...) {
83551       {
83552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83553       };
83554     }
83555   }
83556
83557 }
83558
83559
83560 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
83561   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83562   unsigned int arg2 ;
83563   std::vector< Dali::Actor > *arg3 = 0 ;
83564
83565   arg1 = (Dali::Toolkit::TableView *)jarg1;
83566   arg2 = (unsigned int)jarg2;
83567   arg3 = (std::vector< Dali::Actor > *)jarg3;
83568   if (!arg3) {
83569     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
83570     return ;
83571   }
83572   {
83573     try {
83574       (arg1)->DeleteRow(arg2,*arg3);
83575     } catch (std::out_of_range& e) {
83576       {
83577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83578       };
83579     } catch (std::exception& e) {
83580       {
83581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83582       };
83583     } catch (Dali::DaliException e) {
83584       {
83585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83586       };
83587     } catch (...) {
83588       {
83589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83590       };
83591     }
83592   }
83593
83594 }
83595
83596
83597 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertColumn(void * jarg1, unsigned int jarg2) {
83598   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83599   unsigned int arg2 ;
83600
83601   arg1 = (Dali::Toolkit::TableView *)jarg1;
83602   arg2 = (unsigned int)jarg2;
83603   {
83604     try {
83605       (arg1)->InsertColumn(arg2);
83606     } catch (std::out_of_range& e) {
83607       {
83608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83609       };
83610     } catch (std::exception& e) {
83611       {
83612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83613       };
83614     } catch (Dali::DaliException e) {
83615       {
83616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83617       };
83618     } catch (...) {
83619       {
83620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83621       };
83622     }
83623   }
83624
83625 }
83626
83627
83628 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_0(void * jarg1, unsigned int jarg2) {
83629   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83630   unsigned int arg2 ;
83631
83632   arg1 = (Dali::Toolkit::TableView *)jarg1;
83633   arg2 = (unsigned int)jarg2;
83634   {
83635     try {
83636       (arg1)->DeleteColumn(arg2);
83637     } catch (std::out_of_range& e) {
83638       {
83639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83640       };
83641     } catch (std::exception& e) {
83642       {
83643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83644       };
83645     } catch (Dali::DaliException e) {
83646       {
83647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83648       };
83649     } catch (...) {
83650       {
83651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83652       };
83653     }
83654   }
83655
83656 }
83657
83658
83659 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
83660   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83661   unsigned int arg2 ;
83662   std::vector< Dali::Actor > *arg3 = 0 ;
83663
83664   arg1 = (Dali::Toolkit::TableView *)jarg1;
83665   arg2 = (unsigned int)jarg2;
83666   arg3 = (std::vector< Dali::Actor > *)jarg3;
83667   if (!arg3) {
83668     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
83669     return ;
83670   }
83671   {
83672     try {
83673       (arg1)->DeleteColumn(arg2,*arg3);
83674     } catch (std::out_of_range& e) {
83675       {
83676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83677       };
83678     } catch (std::exception& e) {
83679       {
83680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83681       };
83682     } catch (Dali::DaliException e) {
83683       {
83684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83685       };
83686     } catch (...) {
83687       {
83688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83689       };
83690     }
83691   }
83692
83693 }
83694
83695
83696 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
83697   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83698   unsigned int arg2 ;
83699   unsigned int arg3 ;
83700
83701   arg1 = (Dali::Toolkit::TableView *)jarg1;
83702   arg2 = (unsigned int)jarg2;
83703   arg3 = (unsigned int)jarg3;
83704   {
83705     try {
83706       (arg1)->Resize(arg2,arg3);
83707     } catch (std::out_of_range& e) {
83708       {
83709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83710       };
83711     } catch (std::exception& e) {
83712       {
83713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83714       };
83715     } catch (Dali::DaliException e) {
83716       {
83717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83718       };
83719     } catch (...) {
83720       {
83721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83722       };
83723     }
83724   }
83725
83726 }
83727
83728
83729 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4) {
83730   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83731   unsigned int arg2 ;
83732   unsigned int arg3 ;
83733   std::vector< Dali::Actor > *arg4 = 0 ;
83734
83735   arg1 = (Dali::Toolkit::TableView *)jarg1;
83736   arg2 = (unsigned int)jarg2;
83737   arg3 = (unsigned int)jarg3;
83738   arg4 = (std::vector< Dali::Actor > *)jarg4;
83739   if (!arg4) {
83740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
83741     return ;
83742   }
83743   {
83744     try {
83745       (arg1)->Resize(arg2,arg3,*arg4);
83746     } catch (std::out_of_range& e) {
83747       {
83748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83749       };
83750     } catch (std::exception& e) {
83751       {
83752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83753       };
83754     } catch (Dali::DaliException e) {
83755       {
83756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83757       };
83758     } catch (...) {
83759       {
83760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83761       };
83762     }
83763   }
83764
83765 }
83766
83767
83768 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellPadding(void * jarg1, void * jarg2) {
83769   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83770   Dali::Size arg2 ;
83771   Dali::Size *argp2 ;
83772
83773   arg1 = (Dali::Toolkit::TableView *)jarg1;
83774   argp2 = (Dali::Size *)jarg2;
83775   if (!argp2) {
83776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
83777     return ;
83778   }
83779   arg2 = *argp2;
83780   {
83781     try {
83782       (arg1)->SetCellPadding(arg2);
83783     } catch (std::out_of_range& e) {
83784       {
83785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83786       };
83787     } catch (std::exception& e) {
83788       {
83789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83790       };
83791     } catch (Dali::DaliException e) {
83792       {
83793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83794       };
83795     } catch (...) {
83796       {
83797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83798       };
83799     }
83800   }
83801
83802 }
83803
83804
83805 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetCellPadding(void * jarg1) {
83806   void * jresult ;
83807   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83808   Dali::Size result;
83809
83810   arg1 = (Dali::Toolkit::TableView *)jarg1;
83811   {
83812     try {
83813       result = (arg1)->GetCellPadding();
83814     } catch (std::out_of_range& e) {
83815       {
83816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83817       };
83818     } catch (std::exception& e) {
83819       {
83820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83821       };
83822     } catch (Dali::DaliException e) {
83823       {
83824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83825       };
83826     } catch (...) {
83827       {
83828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83829       };
83830     }
83831   }
83832
83833   jresult = new Dali::Size((const Dali::Size &)result);
83834   return jresult;
83835 }
83836
83837
83838 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitHeight(void * jarg1, unsigned int jarg2) {
83839   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83840   unsigned int arg2 ;
83841
83842   arg1 = (Dali::Toolkit::TableView *)jarg1;
83843   arg2 = (unsigned int)jarg2;
83844   {
83845     try {
83846       (arg1)->SetFitHeight(arg2);
83847     } catch (std::out_of_range& e) {
83848       {
83849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83850       };
83851     } catch (std::exception& e) {
83852       {
83853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83854       };
83855     } catch (Dali::DaliException e) {
83856       {
83857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83858       };
83859     } catch (...) {
83860       {
83861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83862       };
83863     }
83864   }
83865
83866 }
83867
83868
83869 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitHeight(void * jarg1, unsigned int jarg2) {
83870   unsigned int jresult ;
83871   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83872   unsigned int arg2 ;
83873   bool result;
83874
83875   arg1 = (Dali::Toolkit::TableView *)jarg1;
83876   arg2 = (unsigned int)jarg2;
83877   {
83878     try {
83879       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitHeight(arg2);
83880     } catch (std::out_of_range& e) {
83881       {
83882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83883       };
83884     } catch (std::exception& e) {
83885       {
83886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83887       };
83888     } catch (Dali::DaliException e) {
83889       {
83890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83891       };
83892     } catch (...) {
83893       {
83894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83895       };
83896     }
83897   }
83898
83899   jresult = result;
83900   return jresult;
83901 }
83902
83903
83904 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitWidth(void * jarg1, unsigned int jarg2) {
83905   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83906   unsigned int arg2 ;
83907
83908   arg1 = (Dali::Toolkit::TableView *)jarg1;
83909   arg2 = (unsigned int)jarg2;
83910   {
83911     try {
83912       (arg1)->SetFitWidth(arg2);
83913     } catch (std::out_of_range& e) {
83914       {
83915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83916       };
83917     } catch (std::exception& e) {
83918       {
83919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83920       };
83921     } catch (Dali::DaliException e) {
83922       {
83923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83924       };
83925     } catch (...) {
83926       {
83927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83928       };
83929     }
83930   }
83931
83932 }
83933
83934
83935 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitWidth(void * jarg1, unsigned int jarg2) {
83936   unsigned int jresult ;
83937   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83938   unsigned int arg2 ;
83939   bool result;
83940
83941   arg1 = (Dali::Toolkit::TableView *)jarg1;
83942   arg2 = (unsigned int)jarg2;
83943   {
83944     try {
83945       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitWidth(arg2);
83946     } catch (std::out_of_range& e) {
83947       {
83948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83949       };
83950     } catch (std::exception& e) {
83951       {
83952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83953       };
83954     } catch (Dali::DaliException e) {
83955       {
83956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83957       };
83958     } catch (...) {
83959       {
83960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83961       };
83962     }
83963   }
83964
83965   jresult = result;
83966   return jresult;
83967 }
83968
83969
83970 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedHeight(void * jarg1, unsigned int jarg2, float jarg3) {
83971   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83972   unsigned int arg2 ;
83973   float arg3 ;
83974
83975   arg1 = (Dali::Toolkit::TableView *)jarg1;
83976   arg2 = (unsigned int)jarg2;
83977   arg3 = (float)jarg3;
83978   {
83979     try {
83980       (arg1)->SetFixedHeight(arg2,arg3);
83981     } catch (std::out_of_range& e) {
83982       {
83983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83984       };
83985     } catch (std::exception& e) {
83986       {
83987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83988       };
83989     } catch (Dali::DaliException e) {
83990       {
83991         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83992       };
83993     } catch (...) {
83994       {
83995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83996       };
83997     }
83998   }
83999
84000 }
84001
84002
84003 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedHeight(void * jarg1, unsigned int jarg2) {
84004   float jresult ;
84005   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
84006   unsigned int arg2 ;
84007   float result;
84008
84009   arg1 = (Dali::Toolkit::TableView *)jarg1;
84010   arg2 = (unsigned int)jarg2;
84011   {
84012     try {
84013       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedHeight(arg2);
84014     } catch (std::out_of_range& e) {
84015       {
84016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84017       };
84018     } catch (std::exception& e) {
84019       {
84020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84021       };
84022     } catch (Dali::DaliException e) {
84023       {
84024         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84025       };
84026     } catch (...) {
84027       {
84028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84029       };
84030     }
84031   }
84032
84033   jresult = result;
84034   return jresult;
84035 }
84036
84037
84038 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeHeight(void * jarg1, unsigned int jarg2, float jarg3) {
84039   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
84040   unsigned int arg2 ;
84041   float arg3 ;
84042
84043   arg1 = (Dali::Toolkit::TableView *)jarg1;
84044   arg2 = (unsigned int)jarg2;
84045   arg3 = (float)jarg3;
84046   {
84047     try {
84048       (arg1)->SetRelativeHeight(arg2,arg3);
84049     } catch (std::out_of_range& e) {
84050       {
84051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84052       };
84053     } catch (std::exception& e) {
84054       {
84055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84056       };
84057     } catch (Dali::DaliException e) {
84058       {
84059         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84060       };
84061     } catch (...) {
84062       {
84063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84064       };
84065     }
84066   }
84067
84068 }
84069
84070
84071 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeHeight(void * jarg1, unsigned int jarg2) {
84072   float jresult ;
84073   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
84074   unsigned int arg2 ;
84075   float result;
84076
84077   arg1 = (Dali::Toolkit::TableView *)jarg1;
84078   arg2 = (unsigned int)jarg2;
84079   {
84080     try {
84081       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeHeight(arg2);
84082     } catch (std::out_of_range& e) {
84083       {
84084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84085       };
84086     } catch (std::exception& e) {
84087       {
84088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84089       };
84090     } catch (Dali::DaliException e) {
84091       {
84092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84093       };
84094     } catch (...) {
84095       {
84096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84097       };
84098     }
84099   }
84100
84101   jresult = result;
84102   return jresult;
84103 }
84104
84105
84106 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedWidth(void * jarg1, unsigned int jarg2, float jarg3) {
84107   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
84108   unsigned int arg2 ;
84109   float arg3 ;
84110
84111   arg1 = (Dali::Toolkit::TableView *)jarg1;
84112   arg2 = (unsigned int)jarg2;
84113   arg3 = (float)jarg3;
84114   {
84115     try {
84116       (arg1)->SetFixedWidth(arg2,arg3);
84117     } catch (std::out_of_range& e) {
84118       {
84119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84120       };
84121     } catch (std::exception& e) {
84122       {
84123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84124       };
84125     } catch (Dali::DaliException e) {
84126       {
84127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84128       };
84129     } catch (...) {
84130       {
84131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84132       };
84133     }
84134   }
84135
84136 }
84137
84138
84139 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedWidth(void * jarg1, unsigned int jarg2) {
84140   float jresult ;
84141   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
84142   unsigned int arg2 ;
84143   float result;
84144
84145   arg1 = (Dali::Toolkit::TableView *)jarg1;
84146   arg2 = (unsigned int)jarg2;
84147   {
84148     try {
84149       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedWidth(arg2);
84150     } catch (std::out_of_range& e) {
84151       {
84152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84153       };
84154     } catch (std::exception& e) {
84155       {
84156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84157       };
84158     } catch (Dali::DaliException e) {
84159       {
84160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84161       };
84162     } catch (...) {
84163       {
84164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84165       };
84166     }
84167   }
84168
84169   jresult = result;
84170   return jresult;
84171 }
84172
84173
84174 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeWidth(void * jarg1, unsigned int jarg2, float jarg3) {
84175   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
84176   unsigned int arg2 ;
84177   float arg3 ;
84178
84179   arg1 = (Dali::Toolkit::TableView *)jarg1;
84180   arg2 = (unsigned int)jarg2;
84181   arg3 = (float)jarg3;
84182   {
84183     try {
84184       (arg1)->SetRelativeWidth(arg2,arg3);
84185     } catch (std::out_of_range& e) {
84186       {
84187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84188       };
84189     } catch (std::exception& e) {
84190       {
84191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84192       };
84193     } catch (Dali::DaliException e) {
84194       {
84195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84196       };
84197     } catch (...) {
84198       {
84199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84200       };
84201     }
84202   }
84203
84204 }
84205
84206
84207 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeWidth(void * jarg1, unsigned int jarg2) {
84208   float jresult ;
84209   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
84210   unsigned int arg2 ;
84211   float result;
84212
84213   arg1 = (Dali::Toolkit::TableView *)jarg1;
84214   arg2 = (unsigned int)jarg2;
84215   {
84216     try {
84217       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeWidth(arg2);
84218     } catch (std::out_of_range& e) {
84219       {
84220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84221       };
84222     } catch (std::exception& e) {
84223       {
84224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84225       };
84226     } catch (Dali::DaliException e) {
84227       {
84228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84229       };
84230     } catch (...) {
84231       {
84232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84233       };
84234     }
84235   }
84236
84237   jresult = result;
84238   return jresult;
84239 }
84240
84241
84242 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetRows(void * jarg1) {
84243   unsigned int jresult ;
84244   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
84245   unsigned int result;
84246
84247   arg1 = (Dali::Toolkit::TableView *)jarg1;
84248   {
84249     try {
84250       result = (unsigned int)(arg1)->GetRows();
84251     } catch (std::out_of_range& e) {
84252       {
84253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84254       };
84255     } catch (std::exception& e) {
84256       {
84257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84258       };
84259     } catch (Dali::DaliException e) {
84260       {
84261         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84262       };
84263     } catch (...) {
84264       {
84265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84266       };
84267     }
84268   }
84269
84270   jresult = result;
84271   return jresult;
84272 }
84273
84274
84275 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetColumns(void * jarg1) {
84276   unsigned int jresult ;
84277   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
84278   unsigned int result;
84279
84280   arg1 = (Dali::Toolkit::TableView *)jarg1;
84281   {
84282     try {
84283       result = (unsigned int)(arg1)->GetColumns();
84284     } catch (std::out_of_range& e) {
84285       {
84286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84287       };
84288     } catch (std::exception& e) {
84289       {
84290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84291       };
84292     } catch (Dali::DaliException e) {
84293       {
84294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84295       };
84296     } catch (...) {
84297       {
84298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84299       };
84300     }
84301   }
84302
84303   jresult = result;
84304   return jresult;
84305 }
84306
84307
84308 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellAlignment(void * jarg1, void * jarg2, int jarg3, int jarg4) {
84309   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
84310   Dali::Toolkit::TableView::CellPosition arg2 ;
84311   Dali::HorizontalAlignment::Type arg3 ;
84312   Dali::VerticalAlignment::Type arg4 ;
84313   Dali::Toolkit::TableView::CellPosition *argp2 ;
84314
84315   arg1 = (Dali::Toolkit::TableView *)jarg1;
84316   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
84317   if (!argp2) {
84318     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
84319     return ;
84320   }
84321   arg2 = *argp2;
84322   arg3 = (Dali::HorizontalAlignment::Type)jarg3;
84323   arg4 = (Dali::VerticalAlignment::Type)jarg4;
84324   {
84325     try {
84326       (arg1)->SetCellAlignment(arg2,arg3,arg4);
84327     } catch (std::out_of_range& e) {
84328       {
84329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84330       };
84331     } catch (std::exception& e) {
84332       {
84333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84334       };
84335     } catch (Dali::DaliException e) {
84336       {
84337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84338       };
84339     } catch (...) {
84340       {
84341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84342       };
84343     }
84344   }
84345
84346 }
84347
84348
84349 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DEFAULT_RENDERING_BACKEND_get() {
84350   unsigned int jresult ;
84351   unsigned int result;
84352
84353   result = (unsigned int)(unsigned int)Dali::Toolkit::Text::DEFAULT_RENDERING_BACKEND;
84354   jresult = result;
84355   return jresult;
84356 }
84357
84358
84359 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_RENDERING_BACKEND_get() {
84360   int jresult ;
84361   int result;
84362
84363   result = (int)Dali::Toolkit::TextLabel::Property::RENDERING_BACKEND;
84364   jresult = (int)result;
84365   return jresult;
84366 }
84367
84368
84369 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_get() {
84370   int jresult ;
84371   int result;
84372
84373   result = (int)Dali::Toolkit::TextLabel::Property::TEXT;
84374   jresult = (int)result;
84375   return jresult;
84376 }
84377
84378
84379 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_FAMILY_get() {
84380   int jresult ;
84381   int result;
84382
84383   result = (int)Dali::Toolkit::TextLabel::Property::FONT_FAMILY;
84384   jresult = (int)result;
84385   return jresult;
84386 }
84387
84388
84389 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_STYLE_get() {
84390   int jresult ;
84391   int result;
84392
84393   result = (int)Dali::Toolkit::TextLabel::Property::FONT_STYLE;
84394   jresult = (int)result;
84395   return jresult;
84396 }
84397
84398
84399 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_POINT_SIZE_get() {
84400   int jresult ;
84401   int result;
84402
84403   result = (int)Dali::Toolkit::TextLabel::Property::POINT_SIZE;
84404   jresult = (int)result;
84405   return jresult;
84406 }
84407
84408
84409 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_MULTI_LINE_get() {
84410   int jresult ;
84411   int result;
84412
84413   result = (int)Dali::Toolkit::TextLabel::Property::MULTI_LINE;
84414   jresult = (int)result;
84415   return jresult;
84416 }
84417
84418
84419 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_HORIZONTAL_ALIGNMENT_get() {
84420   int jresult ;
84421   int result;
84422
84423   result = (int)Dali::Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT;
84424   jresult = (int)result;
84425   return jresult;
84426 }
84427
84428
84429 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_VERTICAL_ALIGNMENT_get() {
84430   int jresult ;
84431   int result;
84432
84433   result = (int)Dali::Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT;
84434   jresult = (int)result;
84435   return jresult;
84436 }
84437
84438
84439 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_COLOR_get() {
84440   int jresult ;
84441   int result;
84442
84443   result = (int)Dali::Toolkit::TextLabel::Property::TEXT_COLOR;
84444   jresult = (int)result;
84445   return jresult;
84446 }
84447
84448 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_OFFSET_get() {
84449   int jresult ;
84450   int result;
84451
84452   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW_OFFSET;
84453   jresult = (int)result;
84454   return jresult;
84455 }
84456
84457
84458 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_COLOR_get() {
84459   int jresult ;
84460   int result;
84461
84462   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW_COLOR;
84463   jresult = (int)result;
84464   return jresult;
84465 }
84466
84467
84468 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_ENABLED_get() {
84469   int jresult ;
84470   int result;
84471
84472   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_ENABLED;
84473   jresult = (int)result;
84474   return jresult;
84475 }
84476
84477
84478 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_COLOR_get() {
84479   int jresult ;
84480   int result;
84481
84482   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_COLOR;
84483   jresult = (int)result;
84484   return jresult;
84485 }
84486
84487
84488 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_HEIGHT_get() {
84489   int jresult ;
84490   int result;
84491
84492   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_HEIGHT;
84493   jresult = (int)result;
84494   return jresult;
84495 }
84496
84497
84498 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_MARKUP_get() {
84499   int jresult ;
84500   int result;
84501
84502   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_MARKUP;
84503   jresult = (int)result;
84504   return jresult;
84505 }
84506
84507
84508 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_AUTO_SCROLL_get() {
84509   int jresult ;
84510   int result;
84511
84512   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_AUTO_SCROLL;
84513   jresult = (int)result;
84514   return jresult;
84515 }
84516
84517
84518 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_SPEED_get() {
84519   int jresult ;
84520   int result;
84521
84522   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_SPEED;
84523   jresult = (int)result;
84524   return jresult;
84525 }
84526
84527
84528 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_LOOP_COUNT_get() {
84529   int jresult ;
84530   int result;
84531
84532   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_LOOP_COUNT;
84533   jresult = (int)result;
84534   return jresult;
84535 }
84536
84537
84538 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_GAP_get() {
84539   int jresult ;
84540   int result;
84541
84542   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_GAP;
84543   jresult = (int)result;
84544   return jresult;
84545 }
84546
84547
84548 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_LINE_SPACING_get() {
84549   int jresult ;
84550   int result;
84551
84552   result = (int)Dali::Toolkit::TextLabel::Property::LINE_SPACING;
84553   jresult = (int)result;
84554   return jresult;
84555 }
84556
84557
84558 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_get() {
84559   int jresult ;
84560   int result;
84561
84562   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE;
84563   jresult = (int)result;
84564   return jresult;
84565 }
84566
84567
84568 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_get() {
84569   int jresult ;
84570   int result;
84571
84572   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW;
84573   jresult = (int)result;
84574   return jresult;
84575 }
84576
84577
84578 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_EMBOSS_get() {
84579   int jresult ;
84580   int result;
84581
84582   result = (int)Dali::Toolkit::TextLabel::Property::EMBOSS;
84583   jresult = (int)result;
84584   return jresult;
84585 }
84586
84587
84588 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_OUTLINE_get() {
84589   int jresult ;
84590   int result;
84591
84592   result = (int)Dali::Toolkit::TextLabel::Property::OUTLINE;
84593   jresult = (int)result;
84594   return jresult;
84595 }
84596
84597
84598 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel_Property() {
84599   void * jresult ;
84600   Dali::Toolkit::TextLabel::Property *result = 0 ;
84601
84602   {
84603     try {
84604       result = (Dali::Toolkit::TextLabel::Property *)new Dali::Toolkit::TextLabel::Property();
84605     } catch (std::out_of_range& e) {
84606       {
84607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84608       };
84609     } catch (std::exception& e) {
84610       {
84611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84612       };
84613     } catch (Dali::DaliException e) {
84614       {
84615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84616       };
84617     } catch (...) {
84618       {
84619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84620       };
84621     }
84622   }
84623
84624   jresult = (void *)result;
84625   return jresult;
84626 }
84627
84628
84629 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel_Property(void * jarg1) {
84630   Dali::Toolkit::TextLabel::Property *arg1 = (Dali::Toolkit::TextLabel::Property *) 0 ;
84631
84632   arg1 = (Dali::Toolkit::TextLabel::Property *)jarg1;
84633   {
84634     try {
84635       delete arg1;
84636     } catch (std::out_of_range& e) {
84637       {
84638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84639       };
84640     } catch (std::exception& e) {
84641       {
84642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84643       };
84644     } catch (Dali::DaliException e) {
84645       {
84646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84647       };
84648     } catch (...) {
84649       {
84650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84651       };
84652     }
84653   }
84654
84655 }
84656
84657
84658 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_0() {
84659   void * jresult ;
84660   Dali::Toolkit::TextLabel result;
84661
84662   {
84663     try {
84664       result = Dali::Toolkit::TextLabel::New();
84665     } catch (std::out_of_range& e) {
84666       {
84667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84668       };
84669     } catch (std::exception& e) {
84670       {
84671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84672       };
84673     } catch (Dali::DaliException e) {
84674       {
84675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84676       };
84677     } catch (...) {
84678       {
84679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84680       };
84681     }
84682   }
84683
84684   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
84685   return jresult;
84686 }
84687
84688
84689 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_1(char * jarg1) {
84690   void * jresult ;
84691   std::string *arg1 = 0 ;
84692   Dali::Toolkit::TextLabel result;
84693
84694   if (!jarg1) {
84695     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
84696     return 0;
84697   }
84698   std::string arg1_str(jarg1);
84699   arg1 = &arg1_str;
84700   {
84701     try {
84702       result = Dali::Toolkit::TextLabel::New((std::string const &)*arg1);
84703     } catch (std::out_of_range& e) {
84704       {
84705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84706       };
84707     } catch (std::exception& e) {
84708       {
84709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84710       };
84711     } catch (Dali::DaliException e) {
84712       {
84713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84714       };
84715     } catch (...) {
84716       {
84717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84718       };
84719     }
84720   }
84721
84722   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
84723
84724   //argout typemap for const std::string&
84725
84726   return jresult;
84727 }
84728
84729
84730 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_0() {
84731   void * jresult ;
84732   Dali::Toolkit::TextLabel *result = 0 ;
84733
84734   {
84735     try {
84736       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel();
84737     } catch (std::out_of_range& e) {
84738       {
84739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84740       };
84741     } catch (std::exception& e) {
84742       {
84743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84744       };
84745     } catch (Dali::DaliException e) {
84746       {
84747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84748       };
84749     } catch (...) {
84750       {
84751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84752       };
84753     }
84754   }
84755
84756   jresult = (void *)result;
84757   return jresult;
84758 }
84759
84760
84761 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_1(void * jarg1) {
84762   void * jresult ;
84763   Dali::Toolkit::TextLabel *arg1 = 0 ;
84764   Dali::Toolkit::TextLabel *result = 0 ;
84765
84766   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
84767   if (!arg1) {
84768     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
84769     return 0;
84770   }
84771   {
84772     try {
84773       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel((Dali::Toolkit::TextLabel const &)*arg1);
84774     } catch (std::out_of_range& e) {
84775       {
84776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84777       };
84778     } catch (std::exception& e) {
84779       {
84780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84781       };
84782     } catch (Dali::DaliException e) {
84783       {
84784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84785       };
84786     } catch (...) {
84787       {
84788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84789       };
84790     }
84791   }
84792
84793   jresult = (void *)result;
84794   return jresult;
84795 }
84796
84797
84798 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_Assign(void * jarg1, void * jarg2) {
84799   void * jresult ;
84800   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
84801   Dali::Toolkit::TextLabel *arg2 = 0 ;
84802   Dali::Toolkit::TextLabel *result = 0 ;
84803
84804   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
84805   arg2 = (Dali::Toolkit::TextLabel *)jarg2;
84806   if (!arg2) {
84807     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
84808     return 0;
84809   }
84810   {
84811     try {
84812       result = (Dali::Toolkit::TextLabel *) &(arg1)->operator =((Dali::Toolkit::TextLabel const &)*arg2);
84813     } catch (std::out_of_range& e) {
84814       {
84815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84816       };
84817     } catch (std::exception& e) {
84818       {
84819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84820       };
84821     } catch (Dali::DaliException e) {
84822       {
84823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84824       };
84825     } catch (...) {
84826       {
84827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84828       };
84829     }
84830   }
84831
84832   jresult = (void *)result;
84833   return jresult;
84834 }
84835
84836
84837 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel(void * jarg1) {
84838   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
84839
84840   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
84841   {
84842     try {
84843       delete arg1;
84844     } catch (std::out_of_range& e) {
84845       {
84846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84847       };
84848     } catch (std::exception& e) {
84849       {
84850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84851       };
84852     } catch (Dali::DaliException e) {
84853       {
84854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84855       };
84856     } catch (...) {
84857       {
84858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84859       };
84860     }
84861   }
84862
84863 }
84864
84865
84866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_DownCast(void * jarg1) {
84867   void * jresult ;
84868   Dali::BaseHandle arg1 ;
84869   Dali::BaseHandle *argp1 ;
84870   Dali::Toolkit::TextLabel result;
84871
84872   argp1 = (Dali::BaseHandle *)jarg1;
84873   if (!argp1) {
84874     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
84875     return 0;
84876   }
84877   arg1 = *argp1;
84878   {
84879     try {
84880       result = Dali::Toolkit::TextLabel::DownCast(arg1);
84881     } catch (std::out_of_range& e) {
84882       {
84883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84884       };
84885     } catch (std::exception& e) {
84886       {
84887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84888       };
84889     } catch (Dali::DaliException e) {
84890       {
84891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84892       };
84893     } catch (...) {
84894       {
84895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84896       };
84897     }
84898   }
84899
84900   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
84901   return jresult;
84902 }
84903
84904
84905 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityManager() {
84906   void * jresult ;
84907   Dali::Toolkit::AccessibilityManager *result = 0 ;
84908
84909   {
84910     try {
84911       result = (Dali::Toolkit::AccessibilityManager *)new Dali::Toolkit::AccessibilityManager();
84912     } catch (std::out_of_range& e) {
84913       {
84914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84915       };
84916     } catch (std::exception& e) {
84917       {
84918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84919       };
84920     } catch (Dali::DaliException e) {
84921       {
84922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84923       };
84924     } catch (...) {
84925       {
84926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84927       };
84928     }
84929   }
84930
84931   jresult = (void *)result;
84932   return jresult;
84933 }
84934
84935
84936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityManager(void * jarg1) {
84937   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84938
84939   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84940   {
84941     try {
84942       delete arg1;
84943     } catch (std::out_of_range& e) {
84944       {
84945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84946       };
84947     } catch (std::exception& e) {
84948       {
84949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84950       };
84951     } catch (Dali::DaliException e) {
84952       {
84953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84954       };
84955     } catch (...) {
84956       {
84957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84958       };
84959     }
84960   }
84961
84962 }
84963
84964
84965 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_Get() {
84966   void * jresult ;
84967   Dali::Toolkit::AccessibilityManager result;
84968
84969   {
84970     try {
84971       result = Dali::Toolkit::AccessibilityManager::Get();
84972     } catch (std::out_of_range& e) {
84973       {
84974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84975       };
84976     } catch (std::exception& e) {
84977       {
84978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84979       };
84980     } catch (Dali::DaliException e) {
84981       {
84982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84983       };
84984     } catch (...) {
84985       {
84986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84987       };
84988     }
84989   }
84990
84991   jresult = new Dali::Toolkit::AccessibilityManager((const Dali::Toolkit::AccessibilityManager &)result);
84992   return jresult;
84993 }
84994
84995
84996 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3, char * jarg4) {
84997   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84998   Dali::Actor arg2 ;
84999   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
85000   std::string *arg4 = 0 ;
85001   Dali::Actor *argp2 ;
85002
85003   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85004   argp2 = (Dali::Actor *)jarg2;
85005   if (!argp2) {
85006     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85007     return ;
85008   }
85009   arg2 = *argp2;
85010   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
85011   if (!jarg4) {
85012     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85013     return ;
85014   }
85015   std::string arg4_str(jarg4);
85016   arg4 = &arg4_str;
85017   {
85018     try {
85019       (arg1)->SetAccessibilityAttribute(arg2,arg3,(std::string const &)*arg4);
85020     } catch (std::out_of_range& e) {
85021       {
85022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85023       };
85024     } catch (std::exception& e) {
85025       {
85026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85027       };
85028     } catch (Dali::DaliException e) {
85029       {
85030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85031       };
85032     } catch (...) {
85033       {
85034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85035       };
85036     }
85037   }
85038
85039
85040   //argout typemap for const std::string&
85041
85042 }
85043
85044
85045 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3) {
85046   char * jresult ;
85047   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85048   Dali::Actor arg2 ;
85049   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
85050   Dali::Actor *argp2 ;
85051   std::string result;
85052
85053   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85054   argp2 = (Dali::Actor *)jarg2;
85055   if (!argp2) {
85056     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85057     return 0;
85058   }
85059   arg2 = *argp2;
85060   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
85061   {
85062     try {
85063       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetAccessibilityAttribute(arg2,arg3);
85064     } catch (std::out_of_range& e) {
85065       {
85066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85067       };
85068     } catch (std::exception& e) {
85069       {
85070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85071       };
85072     } catch (Dali::DaliException e) {
85073       {
85074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85075       };
85076     } catch (...) {
85077       {
85078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85079       };
85080     }
85081   }
85082
85083   jresult = SWIG_csharp_string_callback((&result)->c_str());
85084   return jresult;
85085 }
85086
85087
85088 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusOrder(void * jarg1, void * jarg2, unsigned int jarg3) {
85089   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85090   Dali::Actor arg2 ;
85091   unsigned int arg3 ;
85092   Dali::Actor *argp2 ;
85093
85094   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85095   argp2 = (Dali::Actor *)jarg2;
85096   if (!argp2) {
85097     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85098     return ;
85099   }
85100   arg2 = *argp2;
85101   arg3 = (unsigned int)jarg3;
85102   {
85103     try {
85104       (arg1)->SetFocusOrder(arg2,arg3);
85105     } catch (std::out_of_range& e) {
85106       {
85107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85108       };
85109     } catch (std::exception& e) {
85110       {
85111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85112       };
85113     } catch (Dali::DaliException e) {
85114       {
85115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85116       };
85117     } catch (...) {
85118       {
85119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85120       };
85121     }
85122   }
85123
85124 }
85125
85126
85127 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusOrder(void * jarg1, void * jarg2) {
85128   unsigned int jresult ;
85129   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85130   Dali::Actor arg2 ;
85131   Dali::Actor *argp2 ;
85132   unsigned int result;
85133
85134   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85135   argp2 = (Dali::Actor *)jarg2;
85136   if (!argp2) {
85137     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85138     return 0;
85139   }
85140   arg2 = *argp2;
85141   {
85142     try {
85143       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetFocusOrder(arg2);
85144     } catch (std::out_of_range& e) {
85145       {
85146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85147       };
85148     } catch (std::exception& e) {
85149       {
85150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85151       };
85152     } catch (Dali::DaliException e) {
85153       {
85154         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85155       };
85156     } catch (...) {
85157       {
85158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85159       };
85160     }
85161   }
85162
85163   jresult = result;
85164   return jresult;
85165 }
85166
85167
85168 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GenerateNewFocusOrder(void * jarg1) {
85169   unsigned int jresult ;
85170   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85171   unsigned int result;
85172
85173   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85174   {
85175     try {
85176       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GenerateNewFocusOrder();
85177     } catch (std::out_of_range& e) {
85178       {
85179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85180       };
85181     } catch (std::exception& e) {
85182       {
85183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85184       };
85185     } catch (Dali::DaliException e) {
85186       {
85187         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85188       };
85189     } catch (...) {
85190       {
85191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85192       };
85193     }
85194   }
85195
85196   jresult = result;
85197   return jresult;
85198 }
85199
85200
85201 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetActorByFocusOrder(void * jarg1, unsigned int jarg2) {
85202   void * jresult ;
85203   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85204   unsigned int arg2 ;
85205   Dali::Actor result;
85206
85207   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85208   arg2 = (unsigned int)jarg2;
85209   {
85210     try {
85211       result = (arg1)->GetActorByFocusOrder(arg2);
85212     } catch (std::out_of_range& e) {
85213       {
85214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85215       };
85216     } catch (std::exception& e) {
85217       {
85218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85219       };
85220     } catch (Dali::DaliException e) {
85221       {
85222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85223       };
85224     } catch (...) {
85225       {
85226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85227       };
85228     }
85229   }
85230
85231   jresult = new Dali::Actor((const Dali::Actor &)result);
85232   return jresult;
85233 }
85234
85235
85236 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetCurrentFocusActor(void * jarg1, void * jarg2) {
85237   unsigned int jresult ;
85238   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85239   Dali::Actor arg2 ;
85240   Dali::Actor *argp2 ;
85241   bool result;
85242
85243   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85244   argp2 = (Dali::Actor *)jarg2;
85245   if (!argp2) {
85246     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85247     return 0;
85248   }
85249   arg2 = *argp2;
85250   {
85251     try {
85252       result = (bool)(arg1)->SetCurrentFocusActor(arg2);
85253     } catch (std::out_of_range& e) {
85254       {
85255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85256       };
85257     } catch (std::exception& e) {
85258       {
85259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85260       };
85261     } catch (Dali::DaliException e) {
85262       {
85263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85264       };
85265     } catch (...) {
85266       {
85267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85268       };
85269     }
85270   }
85271
85272   jresult = result;
85273   return jresult;
85274 }
85275
85276
85277 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusActor(void * jarg1) {
85278   void * jresult ;
85279   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85280   Dali::Actor result;
85281
85282   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85283   {
85284     try {
85285       result = (arg1)->GetCurrentFocusActor();
85286     } catch (std::out_of_range& e) {
85287       {
85288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85289       };
85290     } catch (std::exception& e) {
85291       {
85292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85293       };
85294     } catch (Dali::DaliException e) {
85295       {
85296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85297       };
85298     } catch (...) {
85299       {
85300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85301       };
85302     }
85303   }
85304
85305   jresult = new Dali::Actor((const Dali::Actor &)result);
85306   return jresult;
85307 }
85308
85309
85310 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusGroup(void * jarg1) {
85311   void * jresult ;
85312   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85313   Dali::Actor result;
85314
85315   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85316   {
85317     try {
85318       result = (arg1)->GetCurrentFocusGroup();
85319     } catch (std::out_of_range& e) {
85320       {
85321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85322       };
85323     } catch (std::exception& e) {
85324       {
85325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85326       };
85327     } catch (Dali::DaliException e) {
85328       {
85329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85330       };
85331     } catch (...) {
85332       {
85333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85334       };
85335     }
85336   }
85337
85338   jresult = new Dali::Actor((const Dali::Actor &)result);
85339   return jresult;
85340 }
85341
85342
85343 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusOrder(void * jarg1) {
85344   unsigned int jresult ;
85345   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85346   unsigned int result;
85347
85348   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85349   {
85350     try {
85351       result = (unsigned int)(arg1)->GetCurrentFocusOrder();
85352     } catch (std::out_of_range& e) {
85353       {
85354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85355       };
85356     } catch (std::exception& e) {
85357       {
85358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85359       };
85360     } catch (Dali::DaliException e) {
85361       {
85362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85363       };
85364     } catch (...) {
85365       {
85366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85367       };
85368     }
85369   }
85370
85371   jresult = result;
85372   return jresult;
85373 }
85374
85375
85376 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusForward(void * jarg1) {
85377   unsigned int jresult ;
85378   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85379   bool result;
85380
85381   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85382   {
85383     try {
85384       result = (bool)(arg1)->MoveFocusForward();
85385     } catch (std::out_of_range& e) {
85386       {
85387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85388       };
85389     } catch (std::exception& e) {
85390       {
85391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85392       };
85393     } catch (Dali::DaliException e) {
85394       {
85395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85396       };
85397     } catch (...) {
85398       {
85399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85400       };
85401     }
85402   }
85403
85404   jresult = result;
85405   return jresult;
85406 }
85407
85408
85409 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusBackward(void * jarg1) {
85410   unsigned int jresult ;
85411   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85412   bool result;
85413
85414   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85415   {
85416     try {
85417       result = (bool)(arg1)->MoveFocusBackward();
85418     } catch (std::out_of_range& e) {
85419       {
85420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85421       };
85422     } catch (std::exception& e) {
85423       {
85424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85425       };
85426     } catch (Dali::DaliException e) {
85427       {
85428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85429       };
85430     } catch (...) {
85431       {
85432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85433       };
85434     }
85435   }
85436
85437   jresult = result;
85438   return jresult;
85439 }
85440
85441
85442 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_ClearFocus(void * jarg1) {
85443   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85444
85445   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85446   {
85447     try {
85448       (arg1)->ClearFocus();
85449     } catch (std::out_of_range& e) {
85450       {
85451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85452       };
85453     } catch (std::exception& e) {
85454       {
85455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85456       };
85457     } catch (Dali::DaliException e) {
85458       {
85459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85460       };
85461     } catch (...) {
85462       {
85463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85464       };
85465     }
85466   }
85467
85468 }
85469
85470
85471 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_Reset(void * jarg1) {
85472   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85473
85474   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85475   {
85476     try {
85477       (arg1)->Reset();
85478     } catch (std::out_of_range& e) {
85479       {
85480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85481       };
85482     } catch (std::exception& e) {
85483       {
85484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85485       };
85486     } catch (Dali::DaliException e) {
85487       {
85488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85489       };
85490     } catch (...) {
85491       {
85492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85493       };
85494     }
85495   }
85496
85497 }
85498
85499
85500 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusGroup(void * jarg1, void * jarg2, unsigned int jarg3) {
85501   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85502   Dali::Actor arg2 ;
85503   bool arg3 ;
85504   Dali::Actor *argp2 ;
85505
85506   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85507   argp2 = (Dali::Actor *)jarg2;
85508   if (!argp2) {
85509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85510     return ;
85511   }
85512   arg2 = *argp2;
85513   arg3 = jarg3 ? true : false;
85514   {
85515     try {
85516       (arg1)->SetFocusGroup(arg2,arg3);
85517     } catch (std::out_of_range& e) {
85518       {
85519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85520       };
85521     } catch (std::exception& e) {
85522       {
85523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85524       };
85525     } catch (Dali::DaliException e) {
85526       {
85527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85528       };
85529     } catch (...) {
85530       {
85531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85532       };
85533     }
85534   }
85535
85536 }
85537
85538
85539 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_IsFocusGroup(void * jarg1, void * jarg2) {
85540   unsigned int jresult ;
85541   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85542   Dali::Actor arg2 ;
85543   Dali::Actor *argp2 ;
85544   bool result;
85545
85546   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85547   argp2 = (Dali::Actor *)jarg2;
85548   if (!argp2) {
85549     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85550     return 0;
85551   }
85552   arg2 = *argp2;
85553   {
85554     try {
85555       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->IsFocusGroup(arg2);
85556     } catch (std::out_of_range& e) {
85557       {
85558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85559       };
85560     } catch (std::exception& e) {
85561       {
85562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85563       };
85564     } catch (Dali::DaliException e) {
85565       {
85566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85567       };
85568     } catch (...) {
85569       {
85570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85571       };
85572     }
85573   }
85574
85575   jresult = result;
85576   return jresult;
85577 }
85578
85579
85580 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetGroupMode(void * jarg1, unsigned int jarg2) {
85581   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85582   bool arg2 ;
85583
85584   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85585   arg2 = jarg2 ? true : false;
85586   {
85587     try {
85588       (arg1)->SetGroupMode(arg2);
85589     } catch (std::out_of_range& e) {
85590       {
85591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85592       };
85593     } catch (std::exception& e) {
85594       {
85595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85596       };
85597     } catch (Dali::DaliException e) {
85598       {
85599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85600       };
85601     } catch (...) {
85602       {
85603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85604       };
85605     }
85606   }
85607
85608 }
85609
85610
85611 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetGroupMode(void * jarg1) {
85612   unsigned int jresult ;
85613   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85614   bool result;
85615
85616   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85617   {
85618     try {
85619       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetGroupMode();
85620     } catch (std::out_of_range& e) {
85621       {
85622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85623       };
85624     } catch (std::exception& e) {
85625       {
85626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85627       };
85628     } catch (Dali::DaliException e) {
85629       {
85630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85631       };
85632     } catch (...) {
85633       {
85634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85635       };
85636     }
85637   }
85638
85639   jresult = result;
85640   return jresult;
85641 }
85642
85643
85644 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetWrapMode(void * jarg1, unsigned int jarg2) {
85645   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85646   bool arg2 ;
85647
85648   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85649   arg2 = jarg2 ? true : false;
85650   {
85651     try {
85652       (arg1)->SetWrapMode(arg2);
85653     } catch (std::out_of_range& e) {
85654       {
85655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85656       };
85657     } catch (std::exception& e) {
85658       {
85659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85660       };
85661     } catch (Dali::DaliException e) {
85662       {
85663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85664       };
85665     } catch (...) {
85666       {
85667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85668       };
85669     }
85670   }
85671
85672 }
85673
85674
85675 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetWrapMode(void * jarg1) {
85676   unsigned int jresult ;
85677   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85678   bool result;
85679
85680   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85681   {
85682     try {
85683       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetWrapMode();
85684     } catch (std::out_of_range& e) {
85685       {
85686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85687       };
85688     } catch (std::exception& e) {
85689       {
85690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85691       };
85692     } catch (Dali::DaliException e) {
85693       {
85694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85695       };
85696     } catch (...) {
85697       {
85698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85699       };
85700     }
85701   }
85702
85703   jresult = result;
85704   return jresult;
85705 }
85706
85707
85708 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusIndicatorActor(void * jarg1, void * jarg2) {
85709   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85710   Dali::Actor arg2 ;
85711   Dali::Actor *argp2 ;
85712
85713   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85714   argp2 = (Dali::Actor *)jarg2;
85715   if (!argp2) {
85716     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85717     return ;
85718   }
85719   arg2 = *argp2;
85720   {
85721     try {
85722       (arg1)->SetFocusIndicatorActor(arg2);
85723     } catch (std::out_of_range& e) {
85724       {
85725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85726       };
85727     } catch (std::exception& e) {
85728       {
85729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85730       };
85731     } catch (Dali::DaliException e) {
85732       {
85733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85734       };
85735     } catch (...) {
85736       {
85737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85738       };
85739     }
85740   }
85741
85742 }
85743
85744
85745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusIndicatorActor(void * jarg1) {
85746   void * jresult ;
85747   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85748   Dali::Actor result;
85749
85750   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85751   {
85752     try {
85753       result = (arg1)->GetFocusIndicatorActor();
85754     } catch (std::out_of_range& e) {
85755       {
85756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85757       };
85758     } catch (std::exception& e) {
85759       {
85760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85761       };
85762     } catch (Dali::DaliException e) {
85763       {
85764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85765       };
85766     } catch (...) {
85767       {
85768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85769       };
85770     }
85771   }
85772
85773   jresult = new Dali::Actor((const Dali::Actor &)result);
85774   return jresult;
85775 }
85776
85777
85778 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusGroup(void * jarg1, void * jarg2) {
85779   void * jresult ;
85780   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85781   Dali::Actor arg2 ;
85782   Dali::Actor *argp2 ;
85783   Dali::Actor result;
85784
85785   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85786   argp2 = (Dali::Actor *)jarg2;
85787   if (!argp2) {
85788     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85789     return 0;
85790   }
85791   arg2 = *argp2;
85792   {
85793     try {
85794       result = (arg1)->GetFocusGroup(arg2);
85795     } catch (std::out_of_range& e) {
85796       {
85797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85798       };
85799     } catch (std::exception& e) {
85800       {
85801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85802       };
85803     } catch (Dali::DaliException e) {
85804       {
85805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85806       };
85807     } catch (...) {
85808       {
85809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85810       };
85811     }
85812   }
85813
85814   jresult = new Dali::Actor((const Dali::Actor &)result);
85815   return jresult;
85816 }
85817
85818
85819 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetReadPosition(void * jarg1) {
85820   void * jresult ;
85821   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85822   Dali::Vector2 result;
85823
85824   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85825   {
85826     try {
85827       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetReadPosition();
85828     } catch (std::out_of_range& e) {
85829       {
85830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85831       };
85832     } catch (std::exception& e) {
85833       {
85834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85835       };
85836     } catch (Dali::DaliException e) {
85837       {
85838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85839       };
85840     } catch (...) {
85841       {
85842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85843       };
85844     }
85845   }
85846
85847   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
85848   return jresult;
85849 }
85850
85851
85852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusChangedSignal(void * jarg1) {
85853   void * jresult ;
85854   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85855   Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *result = 0 ;
85856
85857   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85858   {
85859     try {
85860       result = (Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *) &(arg1)->FocusChangedSignal();
85861     } catch (std::out_of_range& e) {
85862       {
85863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85864       };
85865     } catch (std::exception& e) {
85866       {
85867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85868       };
85869     } catch (Dali::DaliException e) {
85870       {
85871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85872       };
85873     } catch (...) {
85874       {
85875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85876       };
85877     }
85878   }
85879
85880   jresult = (void *)result;
85881   return jresult;
85882 }
85883
85884
85885 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusOvershotSignal(void * jarg1) {
85886   void * jresult ;
85887   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85888   Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *result = 0 ;
85889
85890   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85891   {
85892     try {
85893       result = (Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *) &(arg1)->FocusOvershotSignal();
85894     } catch (std::out_of_range& e) {
85895       {
85896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85897       };
85898     } catch (std::exception& e) {
85899       {
85900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85901       };
85902     } catch (Dali::DaliException e) {
85903       {
85904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85905       };
85906     } catch (...) {
85907       {
85908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85909       };
85910     }
85911   }
85912
85913   jresult = (void *)result;
85914   return jresult;
85915 }
85916
85917
85918 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusedActorActivatedSignal(void * jarg1) {
85919   void * jresult ;
85920   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85921   Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *result = 0 ;
85922
85923   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85924   {
85925     try {
85926       result = (Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *) &(arg1)->FocusedActorActivatedSignal();
85927     } catch (std::out_of_range& e) {
85928       {
85929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85930       };
85931     } catch (std::exception& e) {
85932       {
85933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85934       };
85935     } catch (Dali::DaliException e) {
85936       {
85937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85938       };
85939     } catch (...) {
85940       {
85941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85942       };
85943     }
85944   }
85945
85946   jresult = (void *)result;
85947   return jresult;
85948 }
85949
85950
85951 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_StatusChangedSignal(void * jarg1) {
85952   void * jresult ;
85953   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85954   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85955
85956   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85957   {
85958     try {
85959       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->StatusChangedSignal();
85960     } catch (std::out_of_range& e) {
85961       {
85962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85963       };
85964     } catch (std::exception& e) {
85965       {
85966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85967       };
85968     } catch (Dali::DaliException e) {
85969       {
85970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85971       };
85972     } catch (...) {
85973       {
85974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85975       };
85976     }
85977   }
85978
85979   jresult = (void *)result;
85980   return jresult;
85981 }
85982
85983
85984 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionNextSignal(void * jarg1) {
85985   void * jresult ;
85986   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85987   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85988
85989   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85990   {
85991     try {
85992       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionNextSignal();
85993     } catch (std::out_of_range& e) {
85994       {
85995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85996       };
85997     } catch (std::exception& e) {
85998       {
85999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86000       };
86001     } catch (Dali::DaliException e) {
86002       {
86003         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86004       };
86005     } catch (...) {
86006       {
86007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86008       };
86009     }
86010   }
86011
86012   jresult = (void *)result;
86013   return jresult;
86014 }
86015
86016
86017 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPreviousSignal(void * jarg1) {
86018   void * jresult ;
86019   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86020   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86021
86022   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86023   {
86024     try {
86025       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPreviousSignal();
86026     } catch (std::out_of_range& e) {
86027       {
86028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86029       };
86030     } catch (std::exception& e) {
86031       {
86032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86033       };
86034     } catch (Dali::DaliException e) {
86035       {
86036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86037       };
86038     } catch (...) {
86039       {
86040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86041       };
86042     }
86043   }
86044
86045   jresult = (void *)result;
86046   return jresult;
86047 }
86048
86049
86050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionActivateSignal(void * jarg1) {
86051   void * jresult ;
86052   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86053   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86054
86055   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86056   {
86057     try {
86058       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionActivateSignal();
86059     } catch (std::out_of_range& e) {
86060       {
86061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86062       };
86063     } catch (std::exception& e) {
86064       {
86065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86066       };
86067     } catch (Dali::DaliException e) {
86068       {
86069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86070       };
86071     } catch (...) {
86072       {
86073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86074       };
86075     }
86076   }
86077
86078   jresult = (void *)result;
86079   return jresult;
86080 }
86081
86082
86083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadSignal(void * jarg1) {
86084   void * jresult ;
86085   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86086   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86087
86088   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86089   {
86090     try {
86091       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadSignal();
86092     } catch (std::out_of_range& e) {
86093       {
86094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86095       };
86096     } catch (std::exception& e) {
86097       {
86098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86099       };
86100     } catch (Dali::DaliException e) {
86101       {
86102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86103       };
86104     } catch (...) {
86105       {
86106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86107       };
86108     }
86109   }
86110
86111   jresult = (void *)result;
86112   return jresult;
86113 }
86114
86115
86116 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionOverSignal(void * jarg1) {
86117   void * jresult ;
86118   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86119   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86120
86121   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86122   {
86123     try {
86124       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionOverSignal();
86125     } catch (std::out_of_range& e) {
86126       {
86127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86128       };
86129     } catch (std::exception& e) {
86130       {
86131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86132       };
86133     } catch (Dali::DaliException e) {
86134       {
86135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86136       };
86137     } catch (...) {
86138       {
86139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86140       };
86141     }
86142   }
86143
86144   jresult = (void *)result;
86145   return jresult;
86146 }
86147
86148
86149 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadNextSignal(void * jarg1) {
86150   void * jresult ;
86151   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86152   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86153
86154   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86155   {
86156     try {
86157       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadNextSignal();
86158     } catch (std::out_of_range& e) {
86159       {
86160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86161       };
86162     } catch (std::exception& e) {
86163       {
86164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86165       };
86166     } catch (Dali::DaliException e) {
86167       {
86168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86169       };
86170     } catch (...) {
86171       {
86172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86173       };
86174     }
86175   }
86176
86177   jresult = (void *)result;
86178   return jresult;
86179 }
86180
86181
86182 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPreviousSignal(void * jarg1) {
86183   void * jresult ;
86184   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86185   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86186
86187   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86188   {
86189     try {
86190       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPreviousSignal();
86191     } catch (std::out_of_range& e) {
86192       {
86193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86194       };
86195     } catch (std::exception& e) {
86196       {
86197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86198       };
86199     } catch (Dali::DaliException e) {
86200       {
86201         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86202       };
86203     } catch (...) {
86204       {
86205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86206       };
86207     }
86208   }
86209
86210   jresult = (void *)result;
86211   return jresult;
86212 }
86213
86214
86215 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionUpSignal(void * jarg1) {
86216   void * jresult ;
86217   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86218   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86219
86220   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86221   {
86222     try {
86223       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionUpSignal();
86224     } catch (std::out_of_range& e) {
86225       {
86226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86227       };
86228     } catch (std::exception& e) {
86229       {
86230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86231       };
86232     } catch (Dali::DaliException e) {
86233       {
86234         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86235       };
86236     } catch (...) {
86237       {
86238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86239       };
86240     }
86241   }
86242
86243   jresult = (void *)result;
86244   return jresult;
86245 }
86246
86247
86248 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionDownSignal(void * jarg1) {
86249   void * jresult ;
86250   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86251   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86252
86253   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86254   {
86255     try {
86256       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionDownSignal();
86257     } catch (std::out_of_range& e) {
86258       {
86259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86260       };
86261     } catch (std::exception& e) {
86262       {
86263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86264       };
86265     } catch (Dali::DaliException e) {
86266       {
86267         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86268       };
86269     } catch (...) {
86270       {
86271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86272       };
86273     }
86274   }
86275
86276   jresult = (void *)result;
86277   return jresult;
86278 }
86279
86280
86281 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionClearFocusSignal(void * jarg1) {
86282   void * jresult ;
86283   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86284   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86285
86286   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86287   {
86288     try {
86289       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionClearFocusSignal();
86290     } catch (std::out_of_range& e) {
86291       {
86292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86293       };
86294     } catch (std::exception& e) {
86295       {
86296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86297       };
86298     } catch (Dali::DaliException e) {
86299       {
86300         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86301       };
86302     } catch (...) {
86303       {
86304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86305       };
86306     }
86307   }
86308
86309   jresult = (void *)result;
86310   return jresult;
86311 }
86312
86313
86314 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionBackSignal(void * jarg1) {
86315   void * jresult ;
86316   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86317   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86318
86319   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86320   {
86321     try {
86322       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionBackSignal();
86323     } catch (std::out_of_range& e) {
86324       {
86325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86326       };
86327     } catch (std::exception& e) {
86328       {
86329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86330       };
86331     } catch (Dali::DaliException e) {
86332       {
86333         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86334       };
86335     } catch (...) {
86336       {
86337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86338       };
86339     }
86340   }
86341
86342   jresult = (void *)result;
86343   return jresult;
86344 }
86345
86346
86347 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollUpSignal(void * jarg1) {
86348   void * jresult ;
86349   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86350   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86351
86352   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86353   {
86354     try {
86355       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollUpSignal();
86356     } catch (std::out_of_range& e) {
86357       {
86358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86359       };
86360     } catch (std::exception& e) {
86361       {
86362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86363       };
86364     } catch (Dali::DaliException e) {
86365       {
86366         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86367       };
86368     } catch (...) {
86369       {
86370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86371       };
86372     }
86373   }
86374
86375   jresult = (void *)result;
86376   return jresult;
86377 }
86378
86379
86380 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollDownSignal(void * jarg1) {
86381   void * jresult ;
86382   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86383   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86384
86385   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86386   {
86387     try {
86388       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollDownSignal();
86389     } catch (std::out_of_range& e) {
86390       {
86391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86392       };
86393     } catch (std::exception& e) {
86394       {
86395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86396       };
86397     } catch (Dali::DaliException e) {
86398       {
86399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86400       };
86401     } catch (...) {
86402       {
86403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86404       };
86405     }
86406   }
86407
86408   jresult = (void *)result;
86409   return jresult;
86410 }
86411
86412
86413 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageLeftSignal(void * jarg1) {
86414   void * jresult ;
86415   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86416   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86417
86418   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86419   {
86420     try {
86421       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageLeftSignal();
86422     } catch (std::out_of_range& e) {
86423       {
86424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86425       };
86426     } catch (std::exception& e) {
86427       {
86428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86429       };
86430     } catch (Dali::DaliException e) {
86431       {
86432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86433       };
86434     } catch (...) {
86435       {
86436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86437       };
86438     }
86439   }
86440
86441   jresult = (void *)result;
86442   return jresult;
86443 }
86444
86445
86446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageRightSignal(void * jarg1) {
86447   void * jresult ;
86448   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86449   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86450
86451   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86452   {
86453     try {
86454       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageRightSignal();
86455     } catch (std::out_of_range& e) {
86456       {
86457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86458       };
86459     } catch (std::exception& e) {
86460       {
86461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86462       };
86463     } catch (Dali::DaliException e) {
86464       {
86465         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86466       };
86467     } catch (...) {
86468       {
86469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86470       };
86471     }
86472   }
86473
86474   jresult = (void *)result;
86475   return jresult;
86476 }
86477
86478
86479 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageUpSignal(void * jarg1) {
86480   void * jresult ;
86481   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86482   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86483
86484   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86485   {
86486     try {
86487       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageUpSignal();
86488     } catch (std::out_of_range& e) {
86489       {
86490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86491       };
86492     } catch (std::exception& e) {
86493       {
86494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86495       };
86496     } catch (Dali::DaliException e) {
86497       {
86498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86499       };
86500     } catch (...) {
86501       {
86502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86503       };
86504     }
86505   }
86506
86507   jresult = (void *)result;
86508   return jresult;
86509 }
86510
86511
86512 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageDownSignal(void * jarg1) {
86513   void * jresult ;
86514   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86515   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86516
86517   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86518   {
86519     try {
86520       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageDownSignal();
86521     } catch (std::out_of_range& e) {
86522       {
86523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86524       };
86525     } catch (std::exception& e) {
86526       {
86527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86528       };
86529     } catch (Dali::DaliException e) {
86530       {
86531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86532       };
86533     } catch (...) {
86534       {
86535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86536       };
86537     }
86538   }
86539
86540   jresult = (void *)result;
86541   return jresult;
86542 }
86543
86544
86545 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToFirstSignal(void * jarg1) {
86546   void * jresult ;
86547   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86548   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86549
86550   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86551   {
86552     try {
86553       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToFirstSignal();
86554     } catch (std::out_of_range& e) {
86555       {
86556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86557       };
86558     } catch (std::exception& e) {
86559       {
86560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86561       };
86562     } catch (Dali::DaliException e) {
86563       {
86564         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86565       };
86566     } catch (...) {
86567       {
86568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86569       };
86570     }
86571   }
86572
86573   jresult = (void *)result;
86574   return jresult;
86575 }
86576
86577
86578 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToLastSignal(void * jarg1) {
86579   void * jresult ;
86580   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86581   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86582
86583   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86584   {
86585     try {
86586       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToLastSignal();
86587     } catch (std::out_of_range& e) {
86588       {
86589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86590       };
86591     } catch (std::exception& e) {
86592       {
86593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86594       };
86595     } catch (Dali::DaliException e) {
86596       {
86597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86598       };
86599     } catch (...) {
86600       {
86601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86602       };
86603     }
86604   }
86605
86606   jresult = (void *)result;
86607   return jresult;
86608 }
86609
86610
86611 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromTopSignal(void * jarg1) {
86612   void * jresult ;
86613   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86614   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86615
86616   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86617   {
86618     try {
86619       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromTopSignal();
86620     } catch (std::out_of_range& e) {
86621       {
86622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86623       };
86624     } catch (std::exception& e) {
86625       {
86626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86627       };
86628     } catch (Dali::DaliException e) {
86629       {
86630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86631       };
86632     } catch (...) {
86633       {
86634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86635       };
86636     }
86637   }
86638
86639   jresult = (void *)result;
86640   return jresult;
86641 }
86642
86643
86644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromNextSignal(void * jarg1) {
86645   void * jresult ;
86646   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86647   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86648
86649   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86650   {
86651     try {
86652       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromNextSignal();
86653     } catch (std::out_of_range& e) {
86654       {
86655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86656       };
86657     } catch (std::exception& e) {
86658       {
86659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86660       };
86661     } catch (Dali::DaliException e) {
86662       {
86663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86664       };
86665     } catch (...) {
86666       {
86667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86668       };
86669     }
86670   }
86671
86672   jresult = (void *)result;
86673   return jresult;
86674 }
86675
86676
86677 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionZoomSignal(void * jarg1) {
86678   void * jresult ;
86679   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86680   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86681
86682   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86683   {
86684     try {
86685       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionZoomSignal();
86686     } catch (std::out_of_range& e) {
86687       {
86688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86689       };
86690     } catch (std::exception& e) {
86691       {
86692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86693       };
86694     } catch (Dali::DaliException e) {
86695       {
86696         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86697       };
86698     } catch (...) {
86699       {
86700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86701       };
86702     }
86703   }
86704
86705   jresult = (void *)result;
86706   return jresult;
86707 }
86708
86709
86710 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadIndicatorInformationSignal(void * jarg1) {
86711   void * jresult ;
86712   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86713   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86714
86715   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86716   {
86717     try {
86718       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadIndicatorInformationSignal();
86719     } catch (std::out_of_range& e) {
86720       {
86721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86722       };
86723     } catch (std::exception& e) {
86724       {
86725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86726       };
86727     } catch (Dali::DaliException e) {
86728       {
86729         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86730       };
86731     } catch (...) {
86732       {
86733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86734       };
86735     }
86736   }
86737
86738   jresult = (void *)result;
86739   return jresult;
86740 }
86741
86742
86743 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPauseResumeSignal(void * jarg1) {
86744   void * jresult ;
86745   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86746   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86747
86748   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86749   {
86750     try {
86751       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPauseResumeSignal();
86752     } catch (std::out_of_range& e) {
86753       {
86754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86755       };
86756     } catch (std::exception& e) {
86757       {
86758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86759       };
86760     } catch (Dali::DaliException e) {
86761       {
86762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86763       };
86764     } catch (...) {
86765       {
86766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86767       };
86768     }
86769   }
86770
86771   jresult = (void *)result;
86772   return jresult;
86773 }
86774
86775
86776 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionStartStopSignal(void * jarg1) {
86777   void * jresult ;
86778   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86779   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86780
86781   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86782   {
86783     try {
86784       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionStartStopSignal();
86785     } catch (std::out_of_range& e) {
86786       {
86787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86788       };
86789     } catch (std::exception& e) {
86790       {
86791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86792       };
86793     } catch (Dali::DaliException e) {
86794       {
86795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86796       };
86797     } catch (...) {
86798       {
86799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86800       };
86801     }
86802   }
86803
86804   jresult = (void *)result;
86805   return jresult;
86806 }
86807
86808
86809 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollSignal(void * jarg1) {
86810   void * jresult ;
86811   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86812   Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *result = 0 ;
86813
86814   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86815   {
86816     try {
86817       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *) &(arg1)->ActionScrollSignal();
86818     } catch (std::out_of_range& e) {
86819       {
86820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86821       };
86822     } catch (std::exception& e) {
86823       {
86824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86825       };
86826     } catch (Dali::DaliException e) {
86827       {
86828         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86829       };
86830     } catch (...) {
86831       {
86832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86833       };
86834     }
86835   }
86836
86837   jresult = (void *)result;
86838   return jresult;
86839 }
86840
86841
86842 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleManager() {
86843   void * jresult ;
86844   Dali::Toolkit::StyleManager *result = 0 ;
86845
86846   {
86847     try {
86848       result = (Dali::Toolkit::StyleManager *)new Dali::Toolkit::StyleManager();
86849     } catch (std::out_of_range& e) {
86850       {
86851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86852       };
86853     } catch (std::exception& e) {
86854       {
86855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86856       };
86857     } catch (Dali::DaliException e) {
86858       {
86859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86860       };
86861     } catch (...) {
86862       {
86863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86864       };
86865     }
86866   }
86867
86868   jresult = (void *)result;
86869   return jresult;
86870 }
86871
86872
86873 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleManager(void * jarg1) {
86874   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86875
86876   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86877   {
86878     try {
86879       delete arg1;
86880     } catch (std::out_of_range& e) {
86881       {
86882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86883       };
86884     } catch (std::exception& e) {
86885       {
86886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86887       };
86888     } catch (Dali::DaliException e) {
86889       {
86890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86891       };
86892     } catch (...) {
86893       {
86894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86895       };
86896     }
86897   }
86898
86899 }
86900
86901
86902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_Get() {
86903   void * jresult ;
86904   Dali::Toolkit::StyleManager result;
86905
86906   {
86907     try {
86908       result = Dali::Toolkit::StyleManager::Get();
86909     } catch (std::out_of_range& e) {
86910       {
86911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86912       };
86913     } catch (std::exception& e) {
86914       {
86915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86916       };
86917     } catch (Dali::DaliException e) {
86918       {
86919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86920       };
86921     } catch (...) {
86922       {
86923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86924       };
86925     }
86926   }
86927
86928   jresult = new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)result);
86929   return jresult;
86930 }
86931
86932
86933 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyTheme(void * jarg1, char * jarg2) {
86934   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86935   std::string *arg2 = 0 ;
86936
86937   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86938   if (!jarg2) {
86939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86940     return ;
86941   }
86942   std::string arg2_str(jarg2);
86943   arg2 = &arg2_str;
86944   {
86945     try {
86946       (arg1)->ApplyTheme((std::string const &)*arg2);
86947     } catch (std::out_of_range& e) {
86948       {
86949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86950       };
86951     } catch (std::exception& e) {
86952       {
86953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86954       };
86955     } catch (Dali::DaliException e) {
86956       {
86957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86958       };
86959     } catch (...) {
86960       {
86961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86962       };
86963     }
86964   }
86965
86966
86967   //argout typemap for const std::string&
86968
86969 }
86970
86971
86972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyDefaultTheme(void * jarg1) {
86973   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86974
86975   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86976   {
86977     try {
86978       (arg1)->ApplyDefaultTheme();
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
87000
87001 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_SetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
87002   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
87003   std::string *arg2 = 0 ;
87004   Dali::Property::Value *arg3 = 0 ;
87005
87006   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
87007   if (!jarg2) {
87008     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
87009     return ;
87010   }
87011   std::string arg2_str(jarg2);
87012   arg2 = &arg2_str;
87013   arg3 = (Dali::Property::Value *)jarg3;
87014   if (!arg3) {
87015     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
87016     return ;
87017   }
87018   {
87019     try {
87020       (arg1)->SetStyleConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
87021     } catch (std::out_of_range& e) {
87022       {
87023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87024       };
87025     } catch (std::exception& e) {
87026       {
87027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87028       };
87029     } catch (Dali::DaliException e) {
87030       {
87031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87032       };
87033     } catch (...) {
87034       {
87035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87036       };
87037     }
87038   }
87039
87040
87041   //argout typemap for const std::string&
87042
87043 }
87044
87045
87046 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleManager_GetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
87047   unsigned int jresult ;
87048   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
87049   std::string *arg2 = 0 ;
87050   Dali::Property::Value *arg3 = 0 ;
87051   bool result;
87052
87053   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
87054   if (!jarg2) {
87055     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
87056     return 0;
87057   }
87058   std::string arg2_str(jarg2);
87059   arg2 = &arg2_str;
87060   arg3 = (Dali::Property::Value *)jarg3;
87061   if (!arg3) {
87062     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value & type is null", 0);
87063     return 0;
87064   }
87065   {
87066     try {
87067       result = (bool)(arg1)->GetStyleConstant((std::string const &)*arg2,*arg3);
87068     } catch (std::out_of_range& e) {
87069       {
87070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87071       };
87072     } catch (std::exception& e) {
87073       {
87074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87075       };
87076     } catch (Dali::DaliException e) {
87077       {
87078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87079       };
87080     } catch (...) {
87081       {
87082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87083       };
87084     }
87085   }
87086
87087   jresult = result;
87088
87089   //argout typemap for const std::string&
87090
87091   return jresult;
87092 }
87093
87094
87095 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyStyle(void * jarg1, void * jarg2, char * jarg3, char * jarg4) {
87096   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
87097   Dali::Toolkit::Control arg2 ;
87098   std::string *arg3 = 0 ;
87099   std::string *arg4 = 0 ;
87100   Dali::Toolkit::Control *argp2 ;
87101
87102   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
87103   argp2 = (Dali::Toolkit::Control *)jarg2;
87104   if (!argp2) {
87105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
87106     return ;
87107   }
87108   arg2 = *argp2;
87109   if (!jarg3) {
87110     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
87111     return ;
87112   }
87113   std::string arg3_str(jarg3);
87114   arg3 = &arg3_str;
87115   if (!jarg4) {
87116     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
87117     return ;
87118   }
87119   std::string arg4_str(jarg4);
87120   arg4 = &arg4_str;
87121   {
87122     try {
87123       (arg1)->ApplyStyle(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
87124     } catch (std::out_of_range& e) {
87125       {
87126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87127       };
87128     } catch (std::exception& e) {
87129       {
87130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87131       };
87132     } catch (Dali::DaliException e) {
87133       {
87134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87135       };
87136     } catch (...) {
87137       {
87138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87139       };
87140     }
87141   }
87142
87143
87144   //argout typemap for const std::string&
87145
87146
87147   //argout typemap for const std::string&
87148
87149 }
87150
87151
87152 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_StyleChangedSignal(void * jarg1) {
87153   void * jresult ;
87154   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
87155   Dali::Toolkit::StyleManager::StyleChangedSignalType *result = 0 ;
87156
87157   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
87158   {
87159     try {
87160       result = (Dali::Toolkit::StyleManager::StyleChangedSignalType *) &(arg1)->StyleChangedSignal();
87161     } catch (std::out_of_range& e) {
87162       {
87163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87164       };
87165     } catch (std::exception& e) {
87166       {
87167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87168       };
87169     } catch (Dali::DaliException e) {
87170       {
87171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87172       };
87173     } catch (...) {
87174       {
87175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87176       };
87177     }
87178   }
87179
87180   jresult = (void *)result;
87181   return jresult;
87182 }
87183
87184
87185 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_LOWER_BOUND_get() {
87186   int jresult ;
87187   int result;
87188
87189   result = (int)Dali::Toolkit::Slider::Property::LOWER_BOUND;
87190   jresult = (int)result;
87191   return jresult;
87192 }
87193
87194
87195 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_UPPER_BOUND_get() {
87196   int jresult ;
87197   int result;
87198
87199   result = (int)Dali::Toolkit::Slider::Property::UPPER_BOUND;
87200   jresult = (int)result;
87201   return jresult;
87202 }
87203
87204
87205 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_get() {
87206   int jresult ;
87207   int result;
87208
87209   result = (int)Dali::Toolkit::Slider::Property::VALUE;
87210   jresult = (int)result;
87211   return jresult;
87212 }
87213
87214
87215 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_TRACK_VISUAL_get() {
87216   int jresult ;
87217   int result;
87218
87219   result = (int)Dali::Toolkit::Slider::Property::TRACK_VISUAL;
87220   jresult = (int)result;
87221   return jresult;
87222 }
87223
87224
87225 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_HANDLE_VISUAL_get() {
87226   int jresult ;
87227   int result;
87228
87229   result = (int)Dali::Toolkit::Slider::Property::HANDLE_VISUAL;
87230   jresult = (int)result;
87231   return jresult;
87232 }
87233
87234
87235 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_PROGRESS_VISUAL_get() {
87236   int jresult ;
87237   int result;
87238
87239   result = (int)Dali::Toolkit::Slider::Property::PROGRESS_VISUAL;
87240   jresult = (int)result;
87241   return jresult;
87242 }
87243
87244
87245 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_VISUAL_get() {
87246   int jresult ;
87247   int result;
87248
87249   result = (int)Dali::Toolkit::Slider::Property::POPUP_VISUAL;
87250   jresult = (int)result;
87251   return jresult;
87252 }
87253
87254
87255 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_ARROW_VISUAL_get() {
87256   int jresult ;
87257   int result;
87258
87259   result = (int)Dali::Toolkit::Slider::Property::POPUP_ARROW_VISUAL;
87260   jresult = (int)result;
87261   return jresult;
87262 }
87263
87264
87265 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_DISABLED_COLOR_get() {
87266   int jresult ;
87267   int result;
87268
87269   result = (int)Dali::Toolkit::Slider::Property::DISABLED_COLOR;
87270   jresult = (int)result;
87271   return jresult;
87272 }
87273
87274
87275 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_PRECISION_get() {
87276   int jresult ;
87277   int result;
87278
87279   result = (int)Dali::Toolkit::Slider::Property::VALUE_PRECISION;
87280   jresult = (int)result;
87281   return jresult;
87282 }
87283
87284
87285 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_POPUP_get() {
87286   int jresult ;
87287   int result;
87288
87289   result = (int)Dali::Toolkit::Slider::Property::SHOW_POPUP;
87290   jresult = (int)result;
87291   return jresult;
87292 }
87293
87294
87295 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_VALUE_get() {
87296   int jresult ;
87297   int result;
87298
87299   result = (int)Dali::Toolkit::Slider::Property::SHOW_VALUE;
87300   jresult = (int)result;
87301   return jresult;
87302 }
87303
87304
87305 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARKS_get() {
87306   int jresult ;
87307   int result;
87308
87309   result = (int)Dali::Toolkit::Slider::Property::MARKS;
87310   jresult = (int)result;
87311   return jresult;
87312 }
87313
87314
87315 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SNAP_TO_MARKS_get() {
87316   int jresult ;
87317   int result;
87318
87319   result = (int)Dali::Toolkit::Slider::Property::SNAP_TO_MARKS;
87320   jresult = (int)result;
87321   return jresult;
87322 }
87323
87324
87325 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARK_TOLERANCE_get() {
87326   int jresult ;
87327   int result;
87328
87329   result = (int)Dali::Toolkit::Slider::Property::MARK_TOLERANCE;
87330   jresult = (int)result;
87331   return jresult;
87332 }
87333
87334
87335 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider_Property() {
87336   void * jresult ;
87337   Dali::Toolkit::Slider::Property *result = 0 ;
87338
87339   {
87340     try {
87341       result = (Dali::Toolkit::Slider::Property *)new Dali::Toolkit::Slider::Property();
87342     } catch (std::out_of_range& e) {
87343       {
87344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87345       };
87346     } catch (std::exception& e) {
87347       {
87348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87349       };
87350     } catch (Dali::DaliException e) {
87351       {
87352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87353       };
87354     } catch (...) {
87355       {
87356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87357       };
87358     }
87359   }
87360
87361   jresult = (void *)result;
87362   return jresult;
87363 }
87364
87365
87366 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider_Property(void * jarg1) {
87367   Dali::Toolkit::Slider::Property *arg1 = (Dali::Toolkit::Slider::Property *) 0 ;
87368
87369   arg1 = (Dali::Toolkit::Slider::Property *)jarg1;
87370   {
87371     try {
87372       delete arg1;
87373     } catch (std::out_of_range& e) {
87374       {
87375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87376       };
87377     } catch (std::exception& e) {
87378       {
87379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87380       };
87381     } catch (Dali::DaliException e) {
87382       {
87383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87384       };
87385     } catch (...) {
87386       {
87387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87388       };
87389     }
87390   }
87391
87392 }
87393
87394
87395 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_New() {
87396   void * jresult ;
87397   Dali::Toolkit::Slider result;
87398
87399   {
87400     try {
87401       result = Dali::Toolkit::Slider::New();
87402     } catch (std::out_of_range& e) {
87403       {
87404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87405       };
87406     } catch (std::exception& e) {
87407       {
87408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87409       };
87410     } catch (Dali::DaliException e) {
87411       {
87412         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87413       };
87414     } catch (...) {
87415       {
87416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87417       };
87418     }
87419   }
87420
87421   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
87422   return jresult;
87423 }
87424
87425
87426 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_0() {
87427   void * jresult ;
87428   Dali::Toolkit::Slider *result = 0 ;
87429
87430   {
87431     try {
87432       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider();
87433     } catch (std::out_of_range& e) {
87434       {
87435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87436       };
87437     } catch (std::exception& e) {
87438       {
87439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87440       };
87441     } catch (Dali::DaliException e) {
87442       {
87443         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87444       };
87445     } catch (...) {
87446       {
87447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87448       };
87449     }
87450   }
87451
87452   jresult = (void *)result;
87453   return jresult;
87454 }
87455
87456
87457 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_1(void * jarg1) {
87458   void * jresult ;
87459   Dali::Toolkit::Slider *arg1 = 0 ;
87460   Dali::Toolkit::Slider *result = 0 ;
87461
87462   arg1 = (Dali::Toolkit::Slider *)jarg1;
87463   if (!arg1) {
87464     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
87465     return 0;
87466   }
87467   {
87468     try {
87469       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider((Dali::Toolkit::Slider const &)*arg1);
87470     } catch (std::out_of_range& e) {
87471       {
87472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87473       };
87474     } catch (std::exception& e) {
87475       {
87476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87477       };
87478     } catch (Dali::DaliException e) {
87479       {
87480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87481       };
87482     } catch (...) {
87483       {
87484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87485       };
87486     }
87487   }
87488
87489   jresult = (void *)result;
87490   return jresult;
87491 }
87492
87493
87494 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_Assign(void * jarg1, void * jarg2) {
87495   void * jresult ;
87496   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
87497   Dali::Toolkit::Slider *arg2 = 0 ;
87498   Dali::Toolkit::Slider *result = 0 ;
87499
87500   arg1 = (Dali::Toolkit::Slider *)jarg1;
87501   arg2 = (Dali::Toolkit::Slider *)jarg2;
87502   if (!arg2) {
87503     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
87504     return 0;
87505   }
87506   {
87507     try {
87508       result = (Dali::Toolkit::Slider *) &(arg1)->operator =((Dali::Toolkit::Slider const &)*arg2);
87509     } catch (std::out_of_range& e) {
87510       {
87511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87512       };
87513     } catch (std::exception& e) {
87514       {
87515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87516       };
87517     } catch (Dali::DaliException e) {
87518       {
87519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87520       };
87521     } catch (...) {
87522       {
87523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87524       };
87525     }
87526   }
87527
87528   jresult = (void *)result;
87529   return jresult;
87530 }
87531
87532
87533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider(void * jarg1) {
87534   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
87535
87536   arg1 = (Dali::Toolkit::Slider *)jarg1;
87537   {
87538     try {
87539       delete arg1;
87540     } catch (std::out_of_range& e) {
87541       {
87542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87543       };
87544     } catch (std::exception& e) {
87545       {
87546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87547       };
87548     } catch (Dali::DaliException e) {
87549       {
87550         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87551       };
87552     } catch (...) {
87553       {
87554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87555       };
87556     }
87557   }
87558
87559 }
87560
87561
87562 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_DownCast(void * jarg1) {
87563   void * jresult ;
87564   Dali::BaseHandle arg1 ;
87565   Dali::BaseHandle *argp1 ;
87566   Dali::Toolkit::Slider result;
87567
87568   argp1 = (Dali::BaseHandle *)jarg1;
87569   if (!argp1) {
87570     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
87571     return 0;
87572   }
87573   arg1 = *argp1;
87574   {
87575     try {
87576       result = Dali::Toolkit::Slider::DownCast(arg1);
87577     } catch (std::out_of_range& e) {
87578       {
87579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87580       };
87581     } catch (std::exception& e) {
87582       {
87583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87584       };
87585     } catch (Dali::DaliException e) {
87586       {
87587         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87588       };
87589     } catch (...) {
87590       {
87591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87592       };
87593     }
87594   }
87595
87596   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
87597   return jresult;
87598 }
87599
87600
87601 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_ValueChangedSignal(void * jarg1) {
87602   void * jresult ;
87603   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
87604   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
87605
87606   arg1 = (Dali::Toolkit::Slider *)jarg1;
87607   {
87608     try {
87609       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
87610     } catch (std::out_of_range& e) {
87611       {
87612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87613       };
87614     } catch (std::exception& e) {
87615       {
87616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87617       };
87618     } catch (Dali::DaliException e) {
87619       {
87620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87621       };
87622     } catch (...) {
87623       {
87624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87625       };
87626     }
87627   }
87628
87629   jresult = (void *)result;
87630   return jresult;
87631 }
87632
87633
87634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_SlidingFinishedSignal(void * jarg1) {
87635   void * jresult ;
87636   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
87637   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
87638
87639   arg1 = (Dali::Toolkit::Slider *)jarg1;
87640   {
87641     try {
87642       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->SlidingFinishedSignal();
87643     } catch (std::out_of_range& e) {
87644       {
87645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87646       };
87647     } catch (std::exception& e) {
87648       {
87649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87650       };
87651     } catch (Dali::DaliException e) {
87652       {
87653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87654       };
87655     } catch (...) {
87656       {
87657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87658       };
87659     }
87660   }
87661
87662   jresult = (void *)result;
87663   return jresult;
87664 }
87665
87666
87667 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_MarkReachedSignal(void * jarg1) {
87668   void * jresult ;
87669   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
87670   Dali::Toolkit::Slider::MarkReachedSignalType *result = 0 ;
87671
87672   arg1 = (Dali::Toolkit::Slider *)jarg1;
87673   {
87674     try {
87675       result = (Dali::Toolkit::Slider::MarkReachedSignalType *) &(arg1)->MarkReachedSignal();
87676     } catch (std::out_of_range& e) {
87677       {
87678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87679       };
87680     } catch (std::exception& e) {
87681       {
87682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87683       };
87684     } catch (Dali::DaliException e) {
87685       {
87686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87687       };
87688     } catch (...) {
87689       {
87690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87691       };
87692     }
87693   }
87694
87695   jresult = (void *)result;
87696   return jresult;
87697 }
87698
87699
87700 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VIDEO_get() {
87701   int jresult ;
87702   int result;
87703
87704   result = (int)Dali::Toolkit::VideoView::Property::VIDEO;
87705   jresult = (int)result;
87706   return jresult;
87707 }
87708
87709
87710 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_LOOPING_get() {
87711   int jresult ;
87712   int result;
87713
87714   result = (int)Dali::Toolkit::VideoView::Property::LOOPING;
87715   jresult = (int)result;
87716   return jresult;
87717 }
87718
87719
87720 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_MUTED_get() {
87721   int jresult ;
87722   int result;
87723
87724   result = (int)Dali::Toolkit::VideoView::Property::MUTED;
87725   jresult = (int)result;
87726   return jresult;
87727 }
87728
87729
87730 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VOLUME_get() {
87731   int jresult ;
87732   int result;
87733
87734   result = (int)Dali::Toolkit::VideoView::Property::VOLUME;
87735   jresult = (int)result;
87736   return jresult;
87737 }
87738
87739
87740 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_UNDERLAY_get() {
87741   int result;
87742
87743   result = (int)Dali::Toolkit::VideoView::Property::UNDERLAY;
87744
87745   return result;
87746 }
87747
87748
87749 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView_Property() {
87750   void * jresult ;
87751   Dali::Toolkit::VideoView::Property *result = 0 ;
87752
87753   {
87754     try {
87755       result = (Dali::Toolkit::VideoView::Property *)new Dali::Toolkit::VideoView::Property();
87756     } catch (std::out_of_range& e) {
87757       {
87758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87759       };
87760     } catch (std::exception& e) {
87761       {
87762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87763       };
87764     } catch (Dali::DaliException e) {
87765       {
87766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87767       };
87768     } catch (...) {
87769       {
87770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87771       };
87772     }
87773   }
87774
87775   jresult = (void *)result;
87776   return jresult;
87777 }
87778
87779
87780 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView_Property(void * jarg1) {
87781   Dali::Toolkit::VideoView::Property *arg1 = (Dali::Toolkit::VideoView::Property *) 0 ;
87782
87783   arg1 = (Dali::Toolkit::VideoView::Property *)jarg1;
87784   {
87785     try {
87786       delete arg1;
87787     } catch (std::out_of_range& e) {
87788       {
87789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87790       };
87791     } catch (std::exception& e) {
87792       {
87793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87794       };
87795     } catch (Dali::DaliException e) {
87796       {
87797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87798       };
87799     } catch (...) {
87800       {
87801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87802       };
87803     }
87804   }
87805
87806 }
87807
87808
87809 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_0() {
87810   void * jresult ;
87811   Dali::Toolkit::VideoView result;
87812
87813   {
87814     try {
87815       result = Dali::Toolkit::VideoView::New();
87816     } catch (std::out_of_range& e) {
87817       {
87818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87819       };
87820     } catch (std::exception& e) {
87821       {
87822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87823       };
87824     } catch (Dali::DaliException e) {
87825       {
87826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87827       };
87828     } catch (...) {
87829       {
87830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87831       };
87832     }
87833   }
87834
87835   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
87836   return jresult;
87837 }
87838
87839
87840 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_1(char * jarg1) {
87841   void * jresult ;
87842   std::string *arg1 = 0 ;
87843   Dali::Toolkit::VideoView result;
87844
87845   if (!jarg1) {
87846     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
87847     return 0;
87848   }
87849   std::string arg1_str(jarg1);
87850   arg1 = &arg1_str;
87851   {
87852     try {
87853       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1);
87854     } catch (std::out_of_range& e) {
87855       {
87856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87857       };
87858     } catch (std::exception& e) {
87859       {
87860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87861       };
87862     } catch (Dali::DaliException e) {
87863       {
87864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87865       };
87866     } catch (...) {
87867       {
87868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87869       };
87870     }
87871   }
87872
87873   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
87874
87875   //argout typemap for const std::string&
87876
87877   return jresult;
87878 }
87879
87880
87881 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_0() {
87882   void * jresult ;
87883   Dali::Toolkit::VideoView *result = 0 ;
87884
87885   {
87886     try {
87887       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView();
87888     } catch (std::out_of_range& e) {
87889       {
87890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87891       };
87892     } catch (std::exception& e) {
87893       {
87894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87895       };
87896     } catch (Dali::DaliException e) {
87897       {
87898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87899       };
87900     } catch (...) {
87901       {
87902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87903       };
87904     }
87905   }
87906
87907   jresult = (void *)result;
87908   return jresult;
87909 }
87910
87911
87912 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView(void * jarg1) {
87913   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87914
87915   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87916   {
87917     try {
87918       delete arg1;
87919     } catch (std::out_of_range& e) {
87920       {
87921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87922       };
87923     } catch (std::exception& e) {
87924       {
87925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87926       };
87927     } catch (Dali::DaliException e) {
87928       {
87929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87930       };
87931     } catch (...) {
87932       {
87933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87934       };
87935     }
87936   }
87937
87938 }
87939
87940
87941 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_1(void * jarg1) {
87942   void * jresult ;
87943   Dali::Toolkit::VideoView *arg1 = 0 ;
87944   Dali::Toolkit::VideoView *result = 0 ;
87945
87946   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87947   if (!arg1) {
87948     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
87949     return 0;
87950   }
87951   {
87952     try {
87953       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView((Dali::Toolkit::VideoView const &)*arg1);
87954     } catch (std::out_of_range& e) {
87955       {
87956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87957       };
87958     } catch (std::exception& e) {
87959       {
87960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87961       };
87962     } catch (Dali::DaliException e) {
87963       {
87964         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87965       };
87966     } catch (...) {
87967       {
87968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87969       };
87970     }
87971   }
87972
87973   jresult = (void *)result;
87974   return jresult;
87975 }
87976
87977
87978 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_Assign(void * jarg1, void * jarg2) {
87979   void * jresult ;
87980   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87981   Dali::Toolkit::VideoView *arg2 = 0 ;
87982   Dali::Toolkit::VideoView *result = 0 ;
87983
87984   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87985   arg2 = (Dali::Toolkit::VideoView *)jarg2;
87986   if (!arg2) {
87987     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
87988     return 0;
87989   }
87990   {
87991     try {
87992       result = (Dali::Toolkit::VideoView *) &(arg1)->operator =((Dali::Toolkit::VideoView const &)*arg2);
87993     } catch (std::out_of_range& e) {
87994       {
87995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87996       };
87997     } catch (std::exception& e) {
87998       {
87999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88000       };
88001     } catch (Dali::DaliException e) {
88002       {
88003         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88004       };
88005     } catch (...) {
88006       {
88007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88008       };
88009     }
88010   }
88011
88012   jresult = (void *)result;
88013   return jresult;
88014 }
88015
88016
88017 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_DownCast(void * jarg1) {
88018   void * jresult ;
88019   Dali::BaseHandle arg1 ;
88020   Dali::BaseHandle *argp1 ;
88021   Dali::Toolkit::VideoView result;
88022
88023   argp1 = (Dali::BaseHandle *)jarg1;
88024   if (!argp1) {
88025     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
88026     return 0;
88027   }
88028   arg1 = *argp1;
88029   {
88030     try {
88031       result = Dali::Toolkit::VideoView::DownCast(arg1);
88032     } catch (std::out_of_range& e) {
88033       {
88034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88035       };
88036     } catch (std::exception& e) {
88037       {
88038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88039       };
88040     } catch (Dali::DaliException e) {
88041       {
88042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88043       };
88044     } catch (...) {
88045       {
88046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88047       };
88048     }
88049   }
88050
88051   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
88052   return jresult;
88053 }
88054
88055
88056 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Play(void * jarg1) {
88057   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
88058
88059   arg1 = (Dali::Toolkit::VideoView *)jarg1;
88060   {
88061     try {
88062       (arg1)->Play();
88063     } catch (std::out_of_range& e) {
88064       {
88065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88066       };
88067     } catch (std::exception& e) {
88068       {
88069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88070       };
88071     } catch (Dali::DaliException e) {
88072       {
88073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88074       };
88075     } catch (...) {
88076       {
88077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88078       };
88079     }
88080   }
88081
88082 }
88083
88084
88085 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Pause(void * jarg1) {
88086   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
88087
88088   arg1 = (Dali::Toolkit::VideoView *)jarg1;
88089   {
88090     try {
88091       (arg1)->Pause();
88092     } catch (std::out_of_range& e) {
88093       {
88094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88095       };
88096     } catch (std::exception& e) {
88097       {
88098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88099       };
88100     } catch (Dali::DaliException e) {
88101       {
88102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88103       };
88104     } catch (...) {
88105       {
88106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88107       };
88108     }
88109   }
88110
88111 }
88112
88113
88114 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Stop(void * jarg1) {
88115   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
88116
88117   arg1 = (Dali::Toolkit::VideoView *)jarg1;
88118   {
88119     try {
88120       (arg1)->Stop();
88121     } catch (std::out_of_range& e) {
88122       {
88123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88124       };
88125     } catch (std::exception& e) {
88126       {
88127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88128       };
88129     } catch (Dali::DaliException e) {
88130       {
88131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88132       };
88133     } catch (...) {
88134       {
88135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88136       };
88137     }
88138   }
88139
88140 }
88141
88142
88143 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Forward(void * jarg1, int jarg2) {
88144   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
88145   int arg2 ;
88146
88147   arg1 = (Dali::Toolkit::VideoView *)jarg1;
88148   arg2 = (int)jarg2;
88149   {
88150     try {
88151       (arg1)->Forward(arg2);
88152     } catch (std::out_of_range& e) {
88153       {
88154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88155       };
88156     } catch (std::exception& e) {
88157       {
88158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88159       };
88160     } catch (Dali::DaliException e) {
88161       {
88162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88163       };
88164     } catch (...) {
88165       {
88166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88167       };
88168     }
88169   }
88170
88171 }
88172
88173
88174 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Backward(void * jarg1, int jarg2) {
88175   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
88176   int arg2 ;
88177
88178   arg1 = (Dali::Toolkit::VideoView *)jarg1;
88179   arg2 = (int)jarg2;
88180   {
88181     try {
88182       (arg1)->Backward(arg2);
88183     } catch (std::out_of_range& e) {
88184       {
88185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88186       };
88187     } catch (std::exception& e) {
88188       {
88189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88190       };
88191     } catch (Dali::DaliException e) {
88192       {
88193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88194       };
88195     } catch (...) {
88196       {
88197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88198       };
88199     }
88200   }
88201
88202 }
88203
88204
88205 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_FinishedSignal(void * jarg1) {
88206   void * jresult ;
88207   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
88208   Dali::Toolkit::VideoView::VideoViewSignalType *result = 0 ;
88209
88210   arg1 = (Dali::Toolkit::VideoView *)jarg1;
88211   {
88212     try {
88213       result = (Dali::Toolkit::VideoView::VideoViewSignalType *) &(arg1)->FinishedSignal();
88214     } catch (std::out_of_range& e) {
88215       {
88216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88217       };
88218     } catch (std::exception& e) {
88219       {
88220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88221       };
88222     } catch (Dali::DaliException e) {
88223       {
88224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88225       };
88226     } catch (...) {
88227       {
88228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88229       };
88230     }
88231   }
88232
88233   jresult = (void *)result;
88234   return jresult;
88235 }
88236
88237
88238 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TITLE_get() {
88239   int jresult ;
88240   int result;
88241
88242   result = (int)Dali::Toolkit::Popup::Property::TITLE;
88243   jresult = (int)result;
88244   return jresult;
88245 }
88246
88247
88248 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTENT_get() {
88249   int jresult ;
88250   int result;
88251
88252   result = (int)Dali::Toolkit::Popup::Property::CONTENT;
88253   jresult = (int)result;
88254   return jresult;
88255 }
88256
88257
88258 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_FOOTER_get() {
88259   int jresult ;
88260   int result;
88261
88262   result = (int)Dali::Toolkit::Popup::Property::FOOTER;
88263   jresult = (int)result;
88264   return jresult;
88265 }
88266
88267
88268 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_DISPLAY_STATE_get() {
88269   int jresult ;
88270   int result;
88271
88272   result = (int)Dali::Toolkit::Popup::Property::DISPLAY_STATE;
88273   jresult = (int)result;
88274   return jresult;
88275 }
88276
88277
88278 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TOUCH_TRANSPARENT_get() {
88279   int jresult ;
88280   int result;
88281
88282   result = (int)Dali::Toolkit::Popup::Property::TOUCH_TRANSPARENT;
88283   jresult = (int)result;
88284   return jresult;
88285 }
88286
88287
88288 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_VISIBILITY_get() {
88289   int jresult ;
88290   int result;
88291
88292   result = (int)Dali::Toolkit::Popup::Property::TAIL_VISIBILITY;
88293   jresult = (int)result;
88294   return jresult;
88295 }
88296
88297
88298 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_POSITION_get() {
88299   int jresult ;
88300   int result;
88301
88302   result = (int)Dali::Toolkit::Popup::Property::TAIL_POSITION;
88303   jresult = (int)result;
88304   return jresult;
88305 }
88306
88307
88308 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTEXTUAL_MODE_get() {
88309   int jresult ;
88310   int result;
88311
88312   result = (int)Dali::Toolkit::Popup::Property::CONTEXTUAL_MODE;
88313   jresult = (int)result;
88314   return jresult;
88315 }
88316
88317
88318 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_DURATION_get() {
88319   int jresult ;
88320   int result;
88321
88322   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_DURATION;
88323   jresult = (int)result;
88324   return jresult;
88325 }
88326
88327
88328 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_MODE_get() {
88329   int jresult ;
88330   int result;
88331
88332   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_MODE;
88333   jresult = (int)result;
88334   return jresult;
88335 }
88336
88337
88338 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ENTRY_ANIMATION_get() {
88339   int jresult ;
88340   int result;
88341
88342   result = (int)Dali::Toolkit::Popup::Property::ENTRY_ANIMATION;
88343   jresult = (int)result;
88344   return jresult;
88345 }
88346
88347
88348 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_EXIT_ANIMATION_get() {
88349   int jresult ;
88350   int result;
88351
88352   result = (int)Dali::Toolkit::Popup::Property::EXIT_ANIMATION;
88353   jresult = (int)result;
88354   return jresult;
88355 }
88356
88357
88358 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_AUTO_HIDE_DELAY_get() {
88359   int jresult ;
88360   int result;
88361
88362   result = (int)Dali::Toolkit::Popup::Property::AUTO_HIDE_DELAY;
88363   jresult = (int)result;
88364   return jresult;
88365 }
88366
88367
88368 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_ENABLED_get() {
88369   int jresult ;
88370   int result;
88371
88372   result = (int)Dali::Toolkit::Popup::Property::BACKING_ENABLED;
88373   jresult = (int)result;
88374   return jresult;
88375 }
88376
88377
88378 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_COLOR_get() {
88379   int jresult ;
88380   int result;
88381
88382   result = (int)Dali::Toolkit::Popup::Property::BACKING_COLOR;
88383   jresult = (int)result;
88384   return jresult;
88385 }
88386
88387
88388 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_IMAGE_get() {
88389   int jresult ;
88390   int result;
88391
88392   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_IMAGE;
88393   jresult = (int)result;
88394   return jresult;
88395 }
88396
88397
88398 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_BORDER_get() {
88399   int jresult ;
88400   int result;
88401
88402   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_BORDER;
88403   jresult = (int)result;
88404   return jresult;
88405 }
88406
88407
88408 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_UP_IMAGE_get() {
88409   int jresult ;
88410   int result;
88411
88412   result = (int)Dali::Toolkit::Popup::Property::TAIL_UP_IMAGE;
88413   jresult = (int)result;
88414   return jresult;
88415 }
88416
88417
88418 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_DOWN_IMAGE_get() {
88419   int jresult ;
88420   int result;
88421
88422   result = (int)Dali::Toolkit::Popup::Property::TAIL_DOWN_IMAGE;
88423   jresult = (int)result;
88424   return jresult;
88425 }
88426
88427
88428 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_LEFT_IMAGE_get() {
88429   int jresult ;
88430   int result;
88431
88432   result = (int)Dali::Toolkit::Popup::Property::TAIL_LEFT_IMAGE;
88433   jresult = (int)result;
88434   return jresult;
88435 }
88436
88437
88438 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_RIGHT_IMAGE_get() {
88439   int jresult ;
88440   int result;
88441
88442   result = (int)Dali::Toolkit::Popup::Property::TAIL_RIGHT_IMAGE;
88443   jresult = (int)result;
88444   return jresult;
88445 }
88446
88447
88448 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup_Property() {
88449   void * jresult ;
88450   Dali::Toolkit::Popup::Property *result = 0 ;
88451
88452   {
88453     try {
88454       result = (Dali::Toolkit::Popup::Property *)new Dali::Toolkit::Popup::Property();
88455     } catch (std::out_of_range& e) {
88456       {
88457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88458       };
88459     } catch (std::exception& e) {
88460       {
88461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88462       };
88463     } catch (Dali::DaliException e) {
88464       {
88465         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88466       };
88467     } catch (...) {
88468       {
88469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88470       };
88471     }
88472   }
88473
88474   jresult = (void *)result;
88475   return jresult;
88476 }
88477
88478
88479 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup_Property(void * jarg1) {
88480   Dali::Toolkit::Popup::Property *arg1 = (Dali::Toolkit::Popup::Property *) 0 ;
88481
88482   arg1 = (Dali::Toolkit::Popup::Property *)jarg1;
88483   {
88484     try {
88485       delete arg1;
88486     } catch (std::out_of_range& e) {
88487       {
88488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88489       };
88490     } catch (std::exception& e) {
88491       {
88492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88493       };
88494     } catch (Dali::DaliException e) {
88495       {
88496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88497       };
88498     } catch (...) {
88499       {
88500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88501       };
88502     }
88503   }
88504
88505 }
88506
88507
88508 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_0() {
88509   void * jresult ;
88510   Dali::Toolkit::Popup *result = 0 ;
88511
88512   {
88513     try {
88514       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup();
88515     } catch (std::out_of_range& e) {
88516       {
88517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88518       };
88519     } catch (std::exception& e) {
88520       {
88521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88522       };
88523     } catch (Dali::DaliException e) {
88524       {
88525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88526       };
88527     } catch (...) {
88528       {
88529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88530       };
88531     }
88532   }
88533
88534   jresult = (void *)result;
88535   return jresult;
88536 }
88537
88538
88539 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_New() {
88540   void * jresult ;
88541   Dali::Toolkit::Popup result;
88542
88543   {
88544     try {
88545       result = Dali::Toolkit::Popup::New();
88546     } catch (std::out_of_range& e) {
88547       {
88548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88549       };
88550     } catch (std::exception& e) {
88551       {
88552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88553       };
88554     } catch (Dali::DaliException e) {
88555       {
88556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88557       };
88558     } catch (...) {
88559       {
88560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88561       };
88562     }
88563   }
88564
88565   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
88566   return jresult;
88567 }
88568
88569
88570 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup(void * jarg1) {
88571   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88572
88573   arg1 = (Dali::Toolkit::Popup *)jarg1;
88574   {
88575     try {
88576       delete arg1;
88577     } catch (std::out_of_range& e) {
88578       {
88579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88580       };
88581     } catch (std::exception& e) {
88582       {
88583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88584       };
88585     } catch (Dali::DaliException e) {
88586       {
88587         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88588       };
88589     } catch (...) {
88590       {
88591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88592       };
88593     }
88594   }
88595
88596 }
88597
88598
88599 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_1(void * jarg1) {
88600   void * jresult ;
88601   Dali::Toolkit::Popup *arg1 = 0 ;
88602   Dali::Toolkit::Popup *result = 0 ;
88603
88604   arg1 = (Dali::Toolkit::Popup *)jarg1;
88605   if (!arg1) {
88606     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
88607     return 0;
88608   }
88609   {
88610     try {
88611       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup((Dali::Toolkit::Popup const &)*arg1);
88612     } catch (std::out_of_range& e) {
88613       {
88614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88615       };
88616     } catch (std::exception& e) {
88617       {
88618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88619       };
88620     } catch (Dali::DaliException e) {
88621       {
88622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88623       };
88624     } catch (...) {
88625       {
88626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88627       };
88628     }
88629   }
88630
88631   jresult = (void *)result;
88632   return jresult;
88633 }
88634
88635
88636 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_Assign(void * jarg1, void * jarg2) {
88637   void * jresult ;
88638   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88639   Dali::Toolkit::Popup *arg2 = 0 ;
88640   Dali::Toolkit::Popup *result = 0 ;
88641
88642   arg1 = (Dali::Toolkit::Popup *)jarg1;
88643   arg2 = (Dali::Toolkit::Popup *)jarg2;
88644   if (!arg2) {
88645     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
88646     return 0;
88647   }
88648   {
88649     try {
88650       result = (Dali::Toolkit::Popup *) &(arg1)->operator =((Dali::Toolkit::Popup const &)*arg2);
88651     } catch (std::out_of_range& e) {
88652       {
88653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88654       };
88655     } catch (std::exception& e) {
88656       {
88657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88658       };
88659     } catch (Dali::DaliException e) {
88660       {
88661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88662       };
88663     } catch (...) {
88664       {
88665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88666       };
88667     }
88668   }
88669
88670   jresult = (void *)result;
88671   return jresult;
88672 }
88673
88674
88675 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_DownCast(void * jarg1) {
88676   void * jresult ;
88677   Dali::BaseHandle arg1 ;
88678   Dali::BaseHandle *argp1 ;
88679   Dali::Toolkit::Popup result;
88680
88681   argp1 = (Dali::BaseHandle *)jarg1;
88682   if (!argp1) {
88683     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
88684     return 0;
88685   }
88686   arg1 = *argp1;
88687   {
88688     try {
88689       result = Dali::Toolkit::Popup::DownCast(arg1);
88690     } catch (std::out_of_range& e) {
88691       {
88692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88693       };
88694     } catch (std::exception& e) {
88695       {
88696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88697       };
88698     } catch (Dali::DaliException e) {
88699       {
88700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88701       };
88702     } catch (...) {
88703       {
88704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88705       };
88706     }
88707   }
88708
88709   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
88710   return jresult;
88711 }
88712
88713
88714 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetTitle(void * jarg1, void * jarg2) {
88715   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88716   Dali::Actor arg2 ;
88717   Dali::Actor *argp2 ;
88718
88719   arg1 = (Dali::Toolkit::Popup *)jarg1;
88720   argp2 = (Dali::Actor *)jarg2;
88721   if (!argp2) {
88722     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88723     return ;
88724   }
88725   arg2 = *argp2;
88726   {
88727     try {
88728       (arg1)->SetTitle(arg2);
88729     } catch (std::out_of_range& e) {
88730       {
88731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88732       };
88733     } catch (std::exception& e) {
88734       {
88735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88736       };
88737     } catch (Dali::DaliException e) {
88738       {
88739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88740       };
88741     } catch (...) {
88742       {
88743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88744       };
88745     }
88746   }
88747
88748 }
88749
88750
88751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetTitle(void * jarg1) {
88752   void * jresult ;
88753   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88754   Dali::Actor result;
88755
88756   arg1 = (Dali::Toolkit::Popup *)jarg1;
88757   {
88758     try {
88759       result = ((Dali::Toolkit::Popup const *)arg1)->GetTitle();
88760     } catch (std::out_of_range& e) {
88761       {
88762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88763       };
88764     } catch (std::exception& e) {
88765       {
88766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88767       };
88768     } catch (Dali::DaliException e) {
88769       {
88770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88771       };
88772     } catch (...) {
88773       {
88774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88775       };
88776     }
88777   }
88778
88779   jresult = new Dali::Actor((const Dali::Actor &)result);
88780   return jresult;
88781 }
88782
88783
88784 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetContent(void * jarg1, void * jarg2) {
88785   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88786   Dali::Actor arg2 ;
88787   Dali::Actor *argp2 ;
88788
88789   arg1 = (Dali::Toolkit::Popup *)jarg1;
88790   argp2 = (Dali::Actor *)jarg2;
88791   if (!argp2) {
88792     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88793     return ;
88794   }
88795   arg2 = *argp2;
88796   {
88797     try {
88798       (arg1)->SetContent(arg2);
88799     } catch (std::out_of_range& e) {
88800       {
88801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88802       };
88803     } catch (std::exception& e) {
88804       {
88805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88806       };
88807     } catch (Dali::DaliException e) {
88808       {
88809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88810       };
88811     } catch (...) {
88812       {
88813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88814       };
88815     }
88816   }
88817
88818 }
88819
88820
88821 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetContent(void * jarg1) {
88822   void * jresult ;
88823   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88824   Dali::Actor result;
88825
88826   arg1 = (Dali::Toolkit::Popup *)jarg1;
88827   {
88828     try {
88829       result = ((Dali::Toolkit::Popup const *)arg1)->GetContent();
88830     } catch (std::out_of_range& e) {
88831       {
88832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88833       };
88834     } catch (std::exception& e) {
88835       {
88836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88837       };
88838     } catch (Dali::DaliException e) {
88839       {
88840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88841       };
88842     } catch (...) {
88843       {
88844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88845       };
88846     }
88847   }
88848
88849   jresult = new Dali::Actor((const Dali::Actor &)result);
88850   return jresult;
88851 }
88852
88853
88854 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetFooter(void * jarg1, void * jarg2) {
88855   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88856   Dali::Actor arg2 ;
88857   Dali::Actor *argp2 ;
88858
88859   arg1 = (Dali::Toolkit::Popup *)jarg1;
88860   argp2 = (Dali::Actor *)jarg2;
88861   if (!argp2) {
88862     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88863     return ;
88864   }
88865   arg2 = *argp2;
88866   {
88867     try {
88868       (arg1)->SetFooter(arg2);
88869     } catch (std::out_of_range& e) {
88870       {
88871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88872       };
88873     } catch (std::exception& e) {
88874       {
88875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88876       };
88877     } catch (Dali::DaliException e) {
88878       {
88879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88880       };
88881     } catch (...) {
88882       {
88883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88884       };
88885     }
88886   }
88887
88888 }
88889
88890
88891 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetFooter(void * jarg1) {
88892   void * jresult ;
88893   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88894   Dali::Actor result;
88895
88896   arg1 = (Dali::Toolkit::Popup *)jarg1;
88897   {
88898     try {
88899       result = ((Dali::Toolkit::Popup const *)arg1)->GetFooter();
88900     } catch (std::out_of_range& e) {
88901       {
88902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88903       };
88904     } catch (std::exception& e) {
88905       {
88906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88907       };
88908     } catch (Dali::DaliException e) {
88909       {
88910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88911       };
88912     } catch (...) {
88913       {
88914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88915       };
88916     }
88917   }
88918
88919   jresult = new Dali::Actor((const Dali::Actor &)result);
88920   return jresult;
88921 }
88922
88923
88924 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetDisplayState(void * jarg1, int jarg2) {
88925   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88926   Dali::Toolkit::Popup::DisplayState arg2 ;
88927
88928   arg1 = (Dali::Toolkit::Popup *)jarg1;
88929   arg2 = (Dali::Toolkit::Popup::DisplayState)jarg2;
88930   {
88931     try {
88932       (arg1)->SetDisplayState(arg2);
88933     } catch (std::out_of_range& e) {
88934       {
88935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88936       };
88937     } catch (std::exception& e) {
88938       {
88939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88940       };
88941     } catch (Dali::DaliException e) {
88942       {
88943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88944       };
88945     } catch (...) {
88946       {
88947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88948       };
88949     }
88950   }
88951
88952 }
88953
88954
88955 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_GetDisplayState(void * jarg1) {
88956   int jresult ;
88957   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88958   Dali::Toolkit::Popup::DisplayState result;
88959
88960   arg1 = (Dali::Toolkit::Popup *)jarg1;
88961   {
88962     try {
88963       result = (Dali::Toolkit::Popup::DisplayState)((Dali::Toolkit::Popup const *)arg1)->GetDisplayState();
88964     } catch (std::out_of_range& e) {
88965       {
88966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88967       };
88968     } catch (std::exception& e) {
88969       {
88970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88971       };
88972     } catch (Dali::DaliException e) {
88973       {
88974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88975       };
88976     } catch (...) {
88977       {
88978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88979       };
88980     }
88981   }
88982
88983   jresult = (int)result;
88984   return jresult;
88985 }
88986
88987
88988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_OutsideTouchedSignal(void * jarg1) {
88989   void * jresult ;
88990   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88991   Dali::Toolkit::Popup::TouchedOutsideSignalType *result = 0 ;
88992
88993   arg1 = (Dali::Toolkit::Popup *)jarg1;
88994   {
88995     try {
88996       result = (Dali::Toolkit::Popup::TouchedOutsideSignalType *) &(arg1)->OutsideTouchedSignal();
88997     } catch (std::out_of_range& e) {
88998       {
88999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89000       };
89001     } catch (std::exception& e) {
89002       {
89003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89004       };
89005     } catch (Dali::DaliException e) {
89006       {
89007         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89008       };
89009     } catch (...) {
89010       {
89011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89012       };
89013     }
89014   }
89015
89016   jresult = (void *)result;
89017   return jresult;
89018 }
89019
89020
89021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShowingSignal(void * jarg1) {
89022   void * jresult ;
89023   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
89024   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
89025
89026   arg1 = (Dali::Toolkit::Popup *)jarg1;
89027   {
89028     try {
89029       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShowingSignal();
89030     } catch (std::out_of_range& e) {
89031       {
89032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89033       };
89034     } catch (std::exception& e) {
89035       {
89036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89037       };
89038     } catch (Dali::DaliException e) {
89039       {
89040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89041       };
89042     } catch (...) {
89043       {
89044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89045       };
89046     }
89047   }
89048
89049   jresult = (void *)result;
89050   return jresult;
89051 }
89052
89053
89054 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShownSignal(void * jarg1) {
89055   void * jresult ;
89056   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
89057   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
89058
89059   arg1 = (Dali::Toolkit::Popup *)jarg1;
89060   {
89061     try {
89062       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShownSignal();
89063     } catch (std::out_of_range& e) {
89064       {
89065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89066       };
89067     } catch (std::exception& e) {
89068       {
89069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89070       };
89071     } catch (Dali::DaliException e) {
89072       {
89073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89074       };
89075     } catch (...) {
89076       {
89077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89078       };
89079     }
89080   }
89081
89082   jresult = (void *)result;
89083   return jresult;
89084 }
89085
89086
89087 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HidingSignal(void * jarg1) {
89088   void * jresult ;
89089   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
89090   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
89091
89092   arg1 = (Dali::Toolkit::Popup *)jarg1;
89093   {
89094     try {
89095       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HidingSignal();
89096     } catch (std::out_of_range& e) {
89097       {
89098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89099       };
89100     } catch (std::exception& e) {
89101       {
89102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89103       };
89104     } catch (Dali::DaliException e) {
89105       {
89106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89107       };
89108     } catch (...) {
89109       {
89110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89111       };
89112     }
89113   }
89114
89115   jresult = (void *)result;
89116   return jresult;
89117 }
89118
89119
89120 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HiddenSignal(void * jarg1) {
89121   void * jresult ;
89122   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
89123   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
89124
89125   arg1 = (Dali::Toolkit::Popup *)jarg1;
89126   {
89127     try {
89128       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HiddenSignal();
89129     } catch (std::out_of_range& e) {
89130       {
89131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89132       };
89133     } catch (std::exception& e) {
89134       {
89135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89136       };
89137     } catch (Dali::DaliException e) {
89138       {
89139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89140       };
89141     } catch (...) {
89142       {
89143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89144       };
89145     }
89146   }
89147
89148   jresult = (void *)result;
89149   return jresult;
89150 }
89151
89152
89153 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VALUE_get() {
89154   int jresult ;
89155   int result;
89156
89157   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VALUE;
89158   jresult = (int)result;
89159   return jresult;
89160 }
89161
89162
89163 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VALUE_get() {
89164   int jresult ;
89165   int result;
89166
89167   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VALUE;
89168   jresult = (int)result;
89169   return jresult;
89170 }
89171
89172
89173 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_get() {
89174   int jresult ;
89175   int result;
89176
89177   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE;
89178   jresult = (int)result;
89179   return jresult;
89180 }
89181
89182
89183 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_TRACK_VISUAL_get() {
89184   int jresult ;
89185   int result;
89186
89187   result = (int)Dali::Toolkit::ProgressBar::Property::TRACK_VISUAL;
89188   jresult = (int)result;
89189   return jresult;
89190 }
89191
89192
89193 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VISUAL_get() {
89194   int jresult ;
89195   int result;
89196
89197   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VISUAL;
89198   jresult = (int)result;
89199   return jresult;
89200 }
89201
89202
89203 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VISUAL_get() {
89204   int jresult ;
89205   int result;
89206
89207   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL;
89208   jresult = (int)result;
89209   return jresult;
89210 }
89211
89212
89213 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_get() {
89214   int jresult ;
89215   int result;
89216
89217   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL;
89218   jresult = (int)result;
89219   return jresult;
89220 }
89221
89222
89223 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_ANIMATION_get() {
89224   int jresult ;
89225   int result;
89226
89227   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL_ANIMATION;
89228   jresult = (int)result;
89229   return jresult;
89230 }
89231
89232
89233 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_LABEL_VISUAL_get() {
89234   int jresult ;
89235   int result;
89236
89237   result = (int)Dali::Toolkit::ProgressBar::Property::LABEL_VISUAL;
89238   jresult = (int)result;
89239   return jresult;
89240 }
89241
89242
89243 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar_Property() {
89244   void * jresult ;
89245   Dali::Toolkit::ProgressBar::Property *result = 0 ;
89246
89247   {
89248     try {
89249       result = (Dali::Toolkit::ProgressBar::Property *)new Dali::Toolkit::ProgressBar::Property();
89250     } catch (std::out_of_range& e) {
89251       {
89252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89253       };
89254     } catch (std::exception& e) {
89255       {
89256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89257       };
89258     } catch (Dali::DaliException e) {
89259       {
89260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89261       };
89262     } catch (...) {
89263       {
89264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89265       };
89266     }
89267   }
89268
89269   jresult = (void *)result;
89270   return jresult;
89271 }
89272
89273
89274 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar_Property(void * jarg1) {
89275   Dali::Toolkit::ProgressBar::Property *arg1 = (Dali::Toolkit::ProgressBar::Property *) 0 ;
89276
89277   arg1 = (Dali::Toolkit::ProgressBar::Property *)jarg1;
89278   {
89279     try {
89280       delete arg1;
89281     } catch (std::out_of_range& e) {
89282       {
89283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89284       };
89285     } catch (std::exception& e) {
89286       {
89287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89288       };
89289     } catch (Dali::DaliException e) {
89290       {
89291         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89292       };
89293     } catch (...) {
89294       {
89295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89296       };
89297     }
89298   }
89299
89300 }
89301
89302
89303 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_New() {
89304   void * jresult ;
89305   Dali::Toolkit::ProgressBar result;
89306
89307   {
89308     try {
89309       result = Dali::Toolkit::ProgressBar::New();
89310     } catch (std::out_of_range& e) {
89311       {
89312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89313       };
89314     } catch (std::exception& e) {
89315       {
89316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89317       };
89318     } catch (Dali::DaliException e) {
89319       {
89320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89321       };
89322     } catch (...) {
89323       {
89324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89325       };
89326     }
89327   }
89328
89329   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
89330   return jresult;
89331 }
89332
89333
89334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_0() {
89335   void * jresult ;
89336   Dali::Toolkit::ProgressBar *result = 0 ;
89337
89338   {
89339     try {
89340       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar();
89341     } catch (std::out_of_range& e) {
89342       {
89343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89344       };
89345     } catch (std::exception& e) {
89346       {
89347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89348       };
89349     } catch (Dali::DaliException e) {
89350       {
89351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89352       };
89353     } catch (...) {
89354       {
89355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89356       };
89357     }
89358   }
89359
89360   jresult = (void *)result;
89361   return jresult;
89362 }
89363
89364
89365 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_1(void * jarg1) {
89366   void * jresult ;
89367   Dali::Toolkit::ProgressBar *arg1 = 0 ;
89368   Dali::Toolkit::ProgressBar *result = 0 ;
89369
89370   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
89371   if (!arg1) {
89372     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
89373     return 0;
89374   }
89375   {
89376     try {
89377       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar((Dali::Toolkit::ProgressBar const &)*arg1);
89378     } catch (std::out_of_range& e) {
89379       {
89380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89381       };
89382     } catch (std::exception& e) {
89383       {
89384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89385       };
89386     } catch (Dali::DaliException e) {
89387       {
89388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89389       };
89390     } catch (...) {
89391       {
89392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89393       };
89394     }
89395   }
89396
89397   jresult = (void *)result;
89398   return jresult;
89399 }
89400
89401
89402 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_Assign(void * jarg1, void * jarg2) {
89403   void * jresult ;
89404   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
89405   Dali::Toolkit::ProgressBar *arg2 = 0 ;
89406   Dali::Toolkit::ProgressBar *result = 0 ;
89407
89408   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
89409   arg2 = (Dali::Toolkit::ProgressBar *)jarg2;
89410   if (!arg2) {
89411     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
89412     return 0;
89413   }
89414   {
89415     try {
89416       result = (Dali::Toolkit::ProgressBar *) &(arg1)->operator =((Dali::Toolkit::ProgressBar const &)*arg2);
89417     } catch (std::out_of_range& e) {
89418       {
89419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89420       };
89421     } catch (std::exception& e) {
89422       {
89423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89424       };
89425     } catch (Dali::DaliException e) {
89426       {
89427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89428       };
89429     } catch (...) {
89430       {
89431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89432       };
89433     }
89434   }
89435
89436   jresult = (void *)result;
89437   return jresult;
89438 }
89439
89440
89441 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar(void * jarg1) {
89442   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
89443
89444   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
89445   {
89446     try {
89447       delete arg1;
89448     } catch (std::out_of_range& e) {
89449       {
89450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89451       };
89452     } catch (std::exception& e) {
89453       {
89454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89455       };
89456     } catch (Dali::DaliException e) {
89457       {
89458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89459       };
89460     } catch (...) {
89461       {
89462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89463       };
89464     }
89465   }
89466
89467 }
89468
89469
89470 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_DownCast(void * jarg1) {
89471   void * jresult ;
89472   Dali::BaseHandle arg1 ;
89473   Dali::BaseHandle *argp1 ;
89474   Dali::Toolkit::ProgressBar result;
89475
89476   argp1 = (Dali::BaseHandle *)jarg1;
89477   if (!argp1) {
89478     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
89479     return 0;
89480   }
89481   arg1 = *argp1;
89482   {
89483     try {
89484       result = Dali::Toolkit::ProgressBar::DownCast(arg1);
89485     } catch (std::out_of_range& e) {
89486       {
89487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89488       };
89489     } catch (std::exception& e) {
89490       {
89491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89492       };
89493     } catch (Dali::DaliException e) {
89494       {
89495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89496       };
89497     } catch (...) {
89498       {
89499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89500       };
89501     }
89502   }
89503
89504   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
89505   return jresult;
89506 }
89507
89508
89509 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_ValueChangedSignal(void * jarg1) {
89510   void * jresult ;
89511   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
89512   Dali::Toolkit::ProgressBar::ValueChangedSignalType *result = 0 ;
89513
89514   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
89515   {
89516     try {
89517       result = (Dali::Toolkit::ProgressBar::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
89518     } catch (std::out_of_range& e) {
89519       {
89520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89521       };
89522     } catch (std::exception& e) {
89523       {
89524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89525       };
89526     } catch (Dali::DaliException e) {
89527       {
89528         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89529       };
89530     } catch (...) {
89531       {
89532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89533       };
89534     }
89535   }
89536
89537   jresult = (void *)result;
89538   return jresult;
89539 }
89540
89541
89542 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_0() {
89543   void * jresult ;
89544   Dali::Toolkit::GaussianBlurView *result = 0 ;
89545
89546   {
89547     try {
89548       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView();
89549     } catch (std::out_of_range& e) {
89550       {
89551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89552       };
89553     } catch (std::exception& e) {
89554       {
89555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89556       };
89557     } catch (Dali::DaliException e) {
89558       {
89559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89560       };
89561     } catch (...) {
89562       {
89563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89564       };
89565     }
89566   }
89567
89568   jresult = (void *)result;
89569   return jresult;
89570 }
89571
89572
89573 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_1(void * jarg1) {
89574   void * jresult ;
89575   Dali::Toolkit::GaussianBlurView *arg1 = 0 ;
89576   Dali::Toolkit::GaussianBlurView *result = 0 ;
89577
89578   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89579   if (!arg1) {
89580     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
89581     return 0;
89582   }
89583   {
89584     try {
89585       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView((Dali::Toolkit::GaussianBlurView const &)*arg1);
89586     } catch (std::out_of_range& e) {
89587       {
89588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89589       };
89590     } catch (std::exception& e) {
89591       {
89592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89593       };
89594     } catch (Dali::DaliException e) {
89595       {
89596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89597       };
89598     } catch (...) {
89599       {
89600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89601       };
89602     }
89603   }
89604
89605   jresult = (void *)result;
89606   return jresult;
89607 }
89608
89609
89610 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_Assign(void * jarg1, void * jarg2) {
89611   void * jresult ;
89612   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89613   Dali::Toolkit::GaussianBlurView *arg2 = 0 ;
89614   Dali::Toolkit::GaussianBlurView *result = 0 ;
89615
89616   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89617   arg2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
89618   if (!arg2) {
89619     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
89620     return 0;
89621   }
89622   {
89623     try {
89624       result = (Dali::Toolkit::GaussianBlurView *) &(arg1)->operator =((Dali::Toolkit::GaussianBlurView const &)*arg2);
89625     } catch (std::out_of_range& e) {
89626       {
89627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89628       };
89629     } catch (std::exception& e) {
89630       {
89631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89632       };
89633     } catch (Dali::DaliException e) {
89634       {
89635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89636       };
89637     } catch (...) {
89638       {
89639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89640       };
89641     }
89642   }
89643
89644   jresult = (void *)result;
89645   return jresult;
89646 }
89647
89648
89649 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurView(void * jarg1) {
89650   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89651
89652   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89653   {
89654     try {
89655       delete arg1;
89656     } catch (std::out_of_range& e) {
89657       {
89658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89659       };
89660     } catch (std::exception& e) {
89661       {
89662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89663       };
89664     } catch (Dali::DaliException e) {
89665       {
89666         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89667       };
89668     } catch (...) {
89669       {
89670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89671       };
89672     }
89673   }
89674
89675 }
89676
89677
89678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_DownCast(void * jarg1) {
89679   void * jresult ;
89680   Dali::BaseHandle arg1 ;
89681   Dali::BaseHandle *argp1 ;
89682   Dali::Toolkit::GaussianBlurView result;
89683
89684   argp1 = (Dali::BaseHandle *)jarg1;
89685   if (!argp1) {
89686     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
89687     return 0;
89688   }
89689   arg1 = *argp1;
89690   {
89691     try {
89692       result = Dali::Toolkit::GaussianBlurView::DownCast(arg1);
89693     } catch (std::out_of_range& e) {
89694       {
89695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89696       };
89697     } catch (std::exception& e) {
89698       {
89699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89700       };
89701     } catch (Dali::DaliException e) {
89702       {
89703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89704       };
89705     } catch (...) {
89706       {
89707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89708       };
89709     }
89710   }
89711
89712   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
89713   return jresult;
89714 }
89715
89716
89717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_0() {
89718   void * jresult ;
89719   Dali::Toolkit::GaussianBlurView result;
89720
89721   {
89722     try {
89723       result = Dali::Toolkit::GaussianBlurView::New();
89724     } catch (std::out_of_range& e) {
89725       {
89726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89727       };
89728     } catch (std::exception& e) {
89729       {
89730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89731       };
89732     } catch (Dali::DaliException e) {
89733       {
89734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89735       };
89736     } catch (...) {
89737       {
89738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89739       };
89740     }
89741   }
89742
89743   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
89744   return jresult;
89745 }
89746
89747
89748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_1(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5, unsigned int jarg6) {
89749   void * jresult ;
89750   unsigned int arg1 ;
89751   float arg2 ;
89752   Dali::Pixel::Format arg3 ;
89753   float arg4 ;
89754   float arg5 ;
89755   bool arg6 ;
89756   Dali::Toolkit::GaussianBlurView result;
89757
89758   arg1 = (unsigned int)jarg1;
89759   arg2 = (float)jarg2;
89760   arg3 = (Dali::Pixel::Format)jarg3;
89761   arg4 = (float)jarg4;
89762   arg5 = (float)jarg5;
89763   arg6 = jarg6 ? true : false;
89764   {
89765     try {
89766       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5,arg6);
89767     } catch (std::out_of_range& e) {
89768       {
89769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89770       };
89771     } catch (std::exception& e) {
89772       {
89773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89774       };
89775     } catch (Dali::DaliException e) {
89776       {
89777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89778       };
89779     } catch (...) {
89780       {
89781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89782       };
89783     }
89784   }
89785
89786   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
89787   return jresult;
89788 }
89789
89790
89791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_2(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5) {
89792   void * jresult ;
89793   unsigned int arg1 ;
89794   float arg2 ;
89795   Dali::Pixel::Format arg3 ;
89796   float arg4 ;
89797   float arg5 ;
89798   Dali::Toolkit::GaussianBlurView result;
89799
89800   arg1 = (unsigned int)jarg1;
89801   arg2 = (float)jarg2;
89802   arg3 = (Dali::Pixel::Format)jarg3;
89803   arg4 = (float)jarg4;
89804   arg5 = (float)jarg5;
89805   {
89806     try {
89807       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5);
89808     } catch (std::out_of_range& e) {
89809       {
89810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89811       };
89812     } catch (std::exception& e) {
89813       {
89814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89815       };
89816     } catch (Dali::DaliException e) {
89817       {
89818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89819       };
89820     } catch (...) {
89821       {
89822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89823       };
89824     }
89825   }
89826
89827   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
89828   return jresult;
89829 }
89830
89831
89832 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Add(void * jarg1, void * jarg2) {
89833   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89834   Dali::Actor arg2 ;
89835   Dali::Actor *argp2 ;
89836
89837   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89838   argp2 = (Dali::Actor *)jarg2;
89839   if (!argp2) {
89840     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
89841     return ;
89842   }
89843   arg2 = *argp2;
89844   {
89845     try {
89846       (arg1)->Add(arg2);
89847     } catch (std::out_of_range& e) {
89848       {
89849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89850       };
89851     } catch (std::exception& e) {
89852       {
89853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89854       };
89855     } catch (Dali::DaliException e) {
89856       {
89857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89858       };
89859     } catch (...) {
89860       {
89861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89862       };
89863     }
89864   }
89865
89866 }
89867
89868
89869 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Remove(void * jarg1, void * jarg2) {
89870   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89871   Dali::Actor arg2 ;
89872   Dali::Actor *argp2 ;
89873
89874   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89875   argp2 = (Dali::Actor *)jarg2;
89876   if (!argp2) {
89877     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
89878     return ;
89879   }
89880   arg2 = *argp2;
89881   {
89882     try {
89883       (arg1)->Remove(arg2);
89884     } catch (std::out_of_range& e) {
89885       {
89886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89887       };
89888     } catch (std::exception& e) {
89889       {
89890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89891       };
89892     } catch (Dali::DaliException e) {
89893       {
89894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89895       };
89896     } catch (...) {
89897       {
89898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89899       };
89900     }
89901   }
89902
89903 }
89904
89905
89906 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Activate(void * jarg1) {
89907   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89908
89909   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89910   {
89911     try {
89912       (arg1)->Activate();
89913     } catch (std::out_of_range& e) {
89914       {
89915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89916       };
89917     } catch (std::exception& e) {
89918       {
89919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89920       };
89921     } catch (Dali::DaliException e) {
89922       {
89923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89924       };
89925     } catch (...) {
89926       {
89927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89928       };
89929     }
89930   }
89931
89932 }
89933
89934
89935 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_ActivateOnce(void * jarg1) {
89936   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89937
89938   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89939   {
89940     try {
89941       (arg1)->ActivateOnce();
89942     } catch (std::out_of_range& e) {
89943       {
89944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89945       };
89946     } catch (std::exception& e) {
89947       {
89948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89949       };
89950     } catch (Dali::DaliException e) {
89951       {
89952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89953       };
89954     } catch (...) {
89955       {
89956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89957       };
89958     }
89959   }
89960
89961 }
89962
89963
89964 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Deactivate(void * jarg1) {
89965   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89966
89967   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89968   {
89969     try {
89970       (arg1)->Deactivate();
89971     } catch (std::out_of_range& e) {
89972       {
89973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89974       };
89975     } catch (std::exception& e) {
89976       {
89977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89978       };
89979     } catch (Dali::DaliException e) {
89980       {
89981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89982       };
89983     } catch (...) {
89984       {
89985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89986       };
89987     }
89988   }
89989
89990 }
89991
89992
89993 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetUserImageAndOutputRenderTarget(void * jarg1, void * jarg2, void * jarg3) {
89994   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89995   Dali::Image arg2 ;
89996   Dali::FrameBufferImage arg3 ;
89997   Dali::Image *argp2 ;
89998   Dali::FrameBufferImage *argp3 ;
89999
90000   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
90001   argp2 = (Dali::Image *)jarg2;
90002   if (!argp2) {
90003     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
90004     return ;
90005   }
90006   arg2 = *argp2;
90007   argp3 = (Dali::FrameBufferImage *)jarg3;
90008   if (!argp3) {
90009     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
90010     return ;
90011   }
90012   arg3 = *argp3;
90013   {
90014     try {
90015       (arg1)->SetUserImageAndOutputRenderTarget(arg2,arg3);
90016     } catch (std::out_of_range& e) {
90017       {
90018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90019       };
90020     } catch (std::exception& e) {
90021       {
90022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90023       };
90024     } catch (Dali::DaliException e) {
90025       {
90026         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90027       };
90028     } catch (...) {
90029       {
90030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90031       };
90032     }
90033   }
90034
90035 }
90036
90037
90038 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurStrengthPropertyIndex(void * jarg1) {
90039   int jresult ;
90040   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
90041   Dali::Property::Index result;
90042
90043   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
90044   {
90045     try {
90046       result = (Dali::Property::Index)((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurStrengthPropertyIndex();
90047     } catch (std::out_of_range& e) {
90048       {
90049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90050       };
90051     } catch (std::exception& e) {
90052       {
90053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90054       };
90055     } catch (Dali::DaliException e) {
90056       {
90057         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90058       };
90059     } catch (...) {
90060       {
90061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90062       };
90063     }
90064   }
90065
90066   jresult = result;
90067   return jresult;
90068 }
90069
90070
90071 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurredRenderTarget(void * jarg1) {
90072   void * jresult ;
90073   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
90074   Dali::FrameBufferImage result;
90075
90076   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
90077   {
90078     try {
90079       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurredRenderTarget();
90080     } catch (std::out_of_range& e) {
90081       {
90082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90083       };
90084     } catch (std::exception& e) {
90085       {
90086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90087       };
90088     } catch (Dali::DaliException e) {
90089       {
90090         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90091       };
90092     } catch (...) {
90093       {
90094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90095       };
90096     }
90097   }
90098
90099   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
90100   return jresult;
90101 }
90102
90103
90104 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetBackgroundColor(void * jarg1, void * jarg2) {
90105   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
90106   Dali::Vector4 *arg2 = 0 ;
90107
90108   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
90109   arg2 = (Dali::Vector4 *)jarg2;
90110   if (!arg2) {
90111     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
90112     return ;
90113   }
90114   {
90115     try {
90116       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
90117     } catch (std::out_of_range& e) {
90118       {
90119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90120       };
90121     } catch (std::exception& e) {
90122       {
90123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90124       };
90125     } catch (Dali::DaliException e) {
90126       {
90127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90128       };
90129     } catch (...) {
90130       {
90131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90132       };
90133     }
90134   }
90135
90136 }
90137
90138
90139 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBackgroundColor(void * jarg1) {
90140   void * jresult ;
90141   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
90142   Dali::Vector4 result;
90143
90144   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
90145   {
90146     try {
90147       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBackgroundColor();
90148     } catch (std::out_of_range& e) {
90149       {
90150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90151       };
90152     } catch (std::exception& e) {
90153       {
90154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90155       };
90156     } catch (Dali::DaliException e) {
90157       {
90158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90159       };
90160     } catch (...) {
90161       {
90162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90163       };
90164     }
90165   }
90166
90167   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
90168   return jresult;
90169 }
90170
90171
90172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_FinishedSignal(void * jarg1) {
90173   void * jresult ;
90174   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
90175   Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *result = 0 ;
90176
90177   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
90178   {
90179     try {
90180       result = (Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *) &(arg1)->FinishedSignal();
90181     } catch (std::out_of_range& e) {
90182       {
90183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90184       };
90185     } catch (std::exception& e) {
90186       {
90187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90188       };
90189     } catch (Dali::DaliException e) {
90190       {
90191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90192       };
90193     } catch (...) {
90194       {
90195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90196       };
90197     }
90198   }
90199
90200   jresult = (void *)result;
90201   return jresult;
90202 }
90203
90204
90205 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageFactory(void * jarg1) {
90206   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
90207
90208   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
90209   {
90210     try {
90211       delete arg1;
90212     } catch (std::out_of_range& e) {
90213       {
90214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90215       };
90216     } catch (std::exception& e) {
90217       {
90218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90219       };
90220     } catch (Dali::DaliException e) {
90221       {
90222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90223       };
90224     } catch (...) {
90225       {
90226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90227       };
90228     }
90229   }
90230
90231 }
90232
90233
90234 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageFactory_GetNumberOfPages(void * jarg1) {
90235   unsigned int jresult ;
90236   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
90237   unsigned int result;
90238
90239   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
90240   {
90241     try {
90242       result = (unsigned int)(arg1)->GetNumberOfPages();
90243     } catch (std::out_of_range& e) {
90244       {
90245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90246       };
90247     } catch (std::exception& e) {
90248       {
90249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90250       };
90251     } catch (Dali::DaliException e) {
90252       {
90253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90254       };
90255     } catch (...) {
90256       {
90257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90258       };
90259     }
90260   }
90261
90262   jresult = result;
90263   return jresult;
90264 }
90265
90266
90267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageFactory_NewPage(void * jarg1, unsigned int jarg2) {
90268   void * jresult ;
90269   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
90270   unsigned int arg2 ;
90271   Dali::Texture result;
90272
90273   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
90274   arg2 = (unsigned int)jarg2;
90275   {
90276     try {
90277       result = (arg1)->NewPage(arg2);
90278     } catch (std::out_of_range& e) {
90279       {
90280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90281       };
90282     } catch (std::exception& e) {
90283       {
90284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90285       };
90286     } catch (Dali::DaliException e) {
90287       {
90288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90289       };
90290     } catch (...) {
90291       {
90292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90293       };
90294     }
90295   }
90296
90297   jresult = new Dali::Texture((const Dali::Texture &)result);
90298   return jresult;
90299 }
90300
90301
90302 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_PAGE_SIZE_get() {
90303   int jresult ;
90304   int result;
90305
90306   result = (int)Dali::Toolkit::PageTurnView::Property::PAGE_SIZE;
90307   jresult = (int)result;
90308   return jresult;
90309 }
90310
90311
90312 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_CURRENT_PAGE_ID_get() {
90313   int jresult ;
90314   int result;
90315
90316   result = (int)Dali::Toolkit::PageTurnView::Property::CURRENT_PAGE_ID;
90317   jresult = (int)result;
90318   return jresult;
90319 }
90320
90321
90322 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_SPINE_SHADOW_get() {
90323   int jresult ;
90324   int result;
90325
90326   result = (int)Dali::Toolkit::PageTurnView::Property::SPINE_SHADOW;
90327   jresult = (int)result;
90328   return jresult;
90329 }
90330
90331
90332 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView_Property() {
90333   void * jresult ;
90334   Dali::Toolkit::PageTurnView::Property *result = 0 ;
90335
90336   {
90337     try {
90338       result = (Dali::Toolkit::PageTurnView::Property *)new Dali::Toolkit::PageTurnView::Property();
90339     } catch (std::out_of_range& e) {
90340       {
90341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90342       };
90343     } catch (std::exception& e) {
90344       {
90345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90346       };
90347     } catch (Dali::DaliException e) {
90348       {
90349         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90350       };
90351     } catch (...) {
90352       {
90353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90354       };
90355     }
90356   }
90357
90358   jresult = (void *)result;
90359   return jresult;
90360 }
90361
90362
90363 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView_Property(void * jarg1) {
90364   Dali::Toolkit::PageTurnView::Property *arg1 = (Dali::Toolkit::PageTurnView::Property *) 0 ;
90365
90366   arg1 = (Dali::Toolkit::PageTurnView::Property *)jarg1;
90367   {
90368     try {
90369       delete arg1;
90370     } catch (std::out_of_range& e) {
90371       {
90372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90373       };
90374     } catch (std::exception& e) {
90375       {
90376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90377       };
90378     } catch (Dali::DaliException e) {
90379       {
90380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90381       };
90382     } catch (...) {
90383       {
90384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90385       };
90386     }
90387   }
90388
90389 }
90390
90391
90392 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_0() {
90393   void * jresult ;
90394   Dali::Toolkit::PageTurnView *result = 0 ;
90395
90396   {
90397     try {
90398       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView();
90399     } catch (std::out_of_range& e) {
90400       {
90401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90402       };
90403     } catch (std::exception& e) {
90404       {
90405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90406       };
90407     } catch (Dali::DaliException e) {
90408       {
90409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90410       };
90411     } catch (...) {
90412       {
90413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90414       };
90415     }
90416   }
90417
90418   jresult = (void *)result;
90419   return jresult;
90420 }
90421
90422
90423 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_1(void * jarg1) {
90424   void * jresult ;
90425   Dali::Toolkit::PageTurnView *arg1 = 0 ;
90426   Dali::Toolkit::PageTurnView *result = 0 ;
90427
90428   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90429   if (!arg1) {
90430     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
90431     return 0;
90432   }
90433   {
90434     try {
90435       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView((Dali::Toolkit::PageTurnView const &)*arg1);
90436     } catch (std::out_of_range& e) {
90437       {
90438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90439       };
90440     } catch (std::exception& e) {
90441       {
90442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90443       };
90444     } catch (Dali::DaliException e) {
90445       {
90446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90447       };
90448     } catch (...) {
90449       {
90450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90451       };
90452     }
90453   }
90454
90455   jresult = (void *)result;
90456   return jresult;
90457 }
90458
90459
90460 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_Assign(void * jarg1, void * jarg2) {
90461   void * jresult ;
90462   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90463   Dali::Toolkit::PageTurnView *arg2 = 0 ;
90464   Dali::Toolkit::PageTurnView *result = 0 ;
90465
90466   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90467   arg2 = (Dali::Toolkit::PageTurnView *)jarg2;
90468   if (!arg2) {
90469     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
90470     return 0;
90471   }
90472   {
90473     try {
90474       result = (Dali::Toolkit::PageTurnView *) &(arg1)->operator =((Dali::Toolkit::PageTurnView const &)*arg2);
90475     } catch (std::out_of_range& e) {
90476       {
90477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90478       };
90479     } catch (std::exception& e) {
90480       {
90481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90482       };
90483     } catch (Dali::DaliException e) {
90484       {
90485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90486       };
90487     } catch (...) {
90488       {
90489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90490       };
90491     }
90492   }
90493
90494   jresult = (void *)result;
90495   return jresult;
90496 }
90497
90498
90499 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView(void * jarg1) {
90500   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90501
90502   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90503   {
90504     try {
90505       delete arg1;
90506     } catch (std::out_of_range& e) {
90507       {
90508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90509       };
90510     } catch (std::exception& e) {
90511       {
90512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90513       };
90514     } catch (Dali::DaliException e) {
90515       {
90516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90517       };
90518     } catch (...) {
90519       {
90520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90521       };
90522     }
90523   }
90524
90525 }
90526
90527
90528 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_DownCast(void * jarg1) {
90529   void * jresult ;
90530   Dali::BaseHandle arg1 ;
90531   Dali::BaseHandle *argp1 ;
90532   Dali::Toolkit::PageTurnView result;
90533
90534   argp1 = (Dali::BaseHandle *)jarg1;
90535   if (!argp1) {
90536     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
90537     return 0;
90538   }
90539   arg1 = *argp1;
90540   {
90541     try {
90542       result = Dali::Toolkit::PageTurnView::DownCast(arg1);
90543     } catch (std::out_of_range& e) {
90544       {
90545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90546       };
90547     } catch (std::exception& e) {
90548       {
90549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90550       };
90551     } catch (Dali::DaliException e) {
90552       {
90553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90554       };
90555     } catch (...) {
90556       {
90557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90558       };
90559     }
90560   }
90561
90562   jresult = new Dali::Toolkit::PageTurnView((const Dali::Toolkit::PageTurnView &)result);
90563   return jresult;
90564 }
90565
90566
90567 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnStartedSignal(void * jarg1) {
90568   void * jresult ;
90569   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90570   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
90571
90572   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90573   {
90574     try {
90575       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnStartedSignal();
90576     } catch (std::out_of_range& e) {
90577       {
90578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90579       };
90580     } catch (std::exception& e) {
90581       {
90582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90583       };
90584     } catch (Dali::DaliException e) {
90585       {
90586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90587       };
90588     } catch (...) {
90589       {
90590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90591       };
90592     }
90593   }
90594
90595   jresult = (void *)result;
90596   return jresult;
90597 }
90598
90599
90600 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnFinishedSignal(void * jarg1) {
90601   void * jresult ;
90602   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90603   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
90604
90605   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90606   {
90607     try {
90608       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnFinishedSignal();
90609     } catch (std::out_of_range& e) {
90610       {
90611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90612       };
90613     } catch (std::exception& e) {
90614       {
90615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90616       };
90617     } catch (Dali::DaliException e) {
90618       {
90619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90620       };
90621     } catch (...) {
90622       {
90623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90624       };
90625     }
90626   }
90627
90628   jresult = (void *)result;
90629   return jresult;
90630 }
90631
90632
90633 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanStartedSignal(void * jarg1) {
90634   void * jresult ;
90635   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90636   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
90637
90638   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90639   {
90640     try {
90641       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanStartedSignal();
90642     } catch (std::out_of_range& e) {
90643       {
90644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90645       };
90646     } catch (std::exception& e) {
90647       {
90648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90649       };
90650     } catch (Dali::DaliException e) {
90651       {
90652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90653       };
90654     } catch (...) {
90655       {
90656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90657       };
90658     }
90659   }
90660
90661   jresult = (void *)result;
90662   return jresult;
90663 }
90664
90665
90666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanFinishedSignal(void * jarg1) {
90667   void * jresult ;
90668   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90669   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
90670
90671   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90672   {
90673     try {
90674       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanFinishedSignal();
90675     } catch (std::out_of_range& e) {
90676       {
90677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90678       };
90679     } catch (std::exception& e) {
90680       {
90681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90682       };
90683     } catch (Dali::DaliException e) {
90684       {
90685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90686       };
90687     } catch (...) {
90688       {
90689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90690       };
90691     }
90692   }
90693
90694   jresult = (void *)result;
90695   return jresult;
90696 }
90697
90698
90699 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_0() {
90700   void * jresult ;
90701   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
90702
90703   {
90704     try {
90705       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView();
90706     } catch (std::out_of_range& e) {
90707       {
90708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90709       };
90710     } catch (std::exception& e) {
90711       {
90712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90713       };
90714     } catch (Dali::DaliException e) {
90715       {
90716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90717       };
90718     } catch (...) {
90719       {
90720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90721       };
90722     }
90723   }
90724
90725   jresult = (void *)result;
90726   return jresult;
90727 }
90728
90729
90730 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_1(void * jarg1) {
90731   void * jresult ;
90732   Dali::Toolkit::PageTurnLandscapeView *arg1 = 0 ;
90733   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
90734
90735   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
90736   if (!arg1) {
90737     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
90738     return 0;
90739   }
90740   {
90741     try {
90742       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView((Dali::Toolkit::PageTurnLandscapeView const &)*arg1);
90743     } catch (std::out_of_range& e) {
90744       {
90745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90746       };
90747     } catch (std::exception& e) {
90748       {
90749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90750       };
90751     } catch (Dali::DaliException e) {
90752       {
90753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90754       };
90755     } catch (...) {
90756       {
90757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90758       };
90759     }
90760   }
90761
90762   jresult = (void *)result;
90763   return jresult;
90764 }
90765
90766
90767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_Assign(void * jarg1, void * jarg2) {
90768   void * jresult ;
90769   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
90770   Dali::Toolkit::PageTurnLandscapeView *arg2 = 0 ;
90771   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
90772
90773   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
90774   arg2 = (Dali::Toolkit::PageTurnLandscapeView *)jarg2;
90775   if (!arg2) {
90776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
90777     return 0;
90778   }
90779   {
90780     try {
90781       result = (Dali::Toolkit::PageTurnLandscapeView *) &(arg1)->operator =((Dali::Toolkit::PageTurnLandscapeView const &)*arg2);
90782     } catch (std::out_of_range& e) {
90783       {
90784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90785       };
90786     } catch (std::exception& e) {
90787       {
90788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90789       };
90790     } catch (Dali::DaliException e) {
90791       {
90792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90793       };
90794     } catch (...) {
90795       {
90796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90797       };
90798     }
90799   }
90800
90801   jresult = (void *)result;
90802   return jresult;
90803 }
90804
90805
90806 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnLandscapeView(void * jarg1) {
90807   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
90808
90809   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
90810   {
90811     try {
90812       delete arg1;
90813     } catch (std::out_of_range& e) {
90814       {
90815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90816       };
90817     } catch (std::exception& e) {
90818       {
90819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90820       };
90821     } catch (Dali::DaliException e) {
90822       {
90823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90824       };
90825     } catch (...) {
90826       {
90827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90828       };
90829     }
90830   }
90831
90832 }
90833
90834
90835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_New(void * jarg1, void * jarg2) {
90836   void * jresult ;
90837   Dali::Toolkit::PageFactory *arg1 = 0 ;
90838   Dali::Vector2 *arg2 = 0 ;
90839   Dali::Toolkit::PageTurnLandscapeView result;
90840
90841   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
90842   if (!arg1) {
90843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
90844     return 0;
90845   }
90846   arg2 = (Dali::Vector2 *)jarg2;
90847   if (!arg2) {
90848     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
90849     return 0;
90850   }
90851   {
90852     try {
90853       result = Dali::Toolkit::PageTurnLandscapeView::New(*arg1,(Dali::Vector2 const &)*arg2);
90854     } catch (std::out_of_range& e) {
90855       {
90856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90857       };
90858     } catch (std::exception& e) {
90859       {
90860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90861       };
90862     } catch (Dali::DaliException e) {
90863       {
90864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90865       };
90866     } catch (...) {
90867       {
90868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90869       };
90870     }
90871   }
90872
90873   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
90874   return jresult;
90875 }
90876
90877
90878 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_DownCast(void * jarg1) {
90879   void * jresult ;
90880   Dali::BaseHandle arg1 ;
90881   Dali::BaseHandle *argp1 ;
90882   Dali::Toolkit::PageTurnLandscapeView result;
90883
90884   argp1 = (Dali::BaseHandle *)jarg1;
90885   if (!argp1) {
90886     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
90887     return 0;
90888   }
90889   arg1 = *argp1;
90890   {
90891     try {
90892       result = Dali::Toolkit::PageTurnLandscapeView::DownCast(arg1);
90893     } catch (std::out_of_range& e) {
90894       {
90895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90896       };
90897     } catch (std::exception& e) {
90898       {
90899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90900       };
90901     } catch (Dali::DaliException e) {
90902       {
90903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90904       };
90905     } catch (...) {
90906       {
90907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90908       };
90909     }
90910   }
90911
90912   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
90913   return jresult;
90914 }
90915
90916
90917 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_0() {
90918   void * jresult ;
90919   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
90920
90921   {
90922     try {
90923       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView();
90924     } catch (std::out_of_range& e) {
90925       {
90926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90927       };
90928     } catch (std::exception& e) {
90929       {
90930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90931       };
90932     } catch (Dali::DaliException e) {
90933       {
90934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90935       };
90936     } catch (...) {
90937       {
90938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90939       };
90940     }
90941   }
90942
90943   jresult = (void *)result;
90944   return jresult;
90945 }
90946
90947
90948 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_1(void * jarg1) {
90949   void * jresult ;
90950   Dali::Toolkit::PageTurnPortraitView *arg1 = 0 ;
90951   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
90952
90953   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
90954   if (!arg1) {
90955     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
90956     return 0;
90957   }
90958   {
90959     try {
90960       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView((Dali::Toolkit::PageTurnPortraitView const &)*arg1);
90961     } catch (std::out_of_range& e) {
90962       {
90963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90964       };
90965     } catch (std::exception& e) {
90966       {
90967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90968       };
90969     } catch (Dali::DaliException e) {
90970       {
90971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90972       };
90973     } catch (...) {
90974       {
90975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90976       };
90977     }
90978   }
90979
90980   jresult = (void *)result;
90981   return jresult;
90982 }
90983
90984
90985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_Assign(void * jarg1, void * jarg2) {
90986   void * jresult ;
90987   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
90988   Dali::Toolkit::PageTurnPortraitView *arg2 = 0 ;
90989   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
90990
90991   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
90992   arg2 = (Dali::Toolkit::PageTurnPortraitView *)jarg2;
90993   if (!arg2) {
90994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
90995     return 0;
90996   }
90997   {
90998     try {
90999       result = (Dali::Toolkit::PageTurnPortraitView *) &(arg1)->operator =((Dali::Toolkit::PageTurnPortraitView const &)*arg2);
91000     } catch (std::out_of_range& e) {
91001       {
91002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91003       };
91004     } catch (std::exception& e) {
91005       {
91006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91007       };
91008     } catch (Dali::DaliException e) {
91009       {
91010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91011       };
91012     } catch (...) {
91013       {
91014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91015       };
91016     }
91017   }
91018
91019   jresult = (void *)result;
91020   return jresult;
91021 }
91022
91023
91024 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnPortraitView(void * jarg1) {
91025   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
91026
91027   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
91028   {
91029     try {
91030       delete arg1;
91031     } catch (std::out_of_range& e) {
91032       {
91033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91034       };
91035     } catch (std::exception& e) {
91036       {
91037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91038       };
91039     } catch (Dali::DaliException e) {
91040       {
91041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91042       };
91043     } catch (...) {
91044       {
91045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91046       };
91047     }
91048   }
91049
91050 }
91051
91052
91053 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_New(void * jarg1, void * jarg2) {
91054   void * jresult ;
91055   Dali::Toolkit::PageFactory *arg1 = 0 ;
91056   Dali::Vector2 *arg2 = 0 ;
91057   Dali::Toolkit::PageTurnPortraitView result;
91058
91059   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
91060   if (!arg1) {
91061     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
91062     return 0;
91063   }
91064   arg2 = (Dali::Vector2 *)jarg2;
91065   if (!arg2) {
91066     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
91067     return 0;
91068   }
91069   {
91070     try {
91071       result = Dali::Toolkit::PageTurnPortraitView::New(*arg1,(Dali::Vector2 const &)*arg2);
91072     } catch (std::out_of_range& e) {
91073       {
91074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91075       };
91076     } catch (std::exception& e) {
91077       {
91078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91079       };
91080     } catch (Dali::DaliException e) {
91081       {
91082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91083       };
91084     } catch (...) {
91085       {
91086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91087       };
91088     }
91089   }
91090
91091   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
91092   return jresult;
91093 }
91094
91095
91096 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_DownCast(void * jarg1) {
91097   void * jresult ;
91098   Dali::BaseHandle arg1 ;
91099   Dali::BaseHandle *argp1 ;
91100   Dali::Toolkit::PageTurnPortraitView result;
91101
91102   argp1 = (Dali::BaseHandle *)jarg1;
91103   if (!argp1) {
91104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
91105     return 0;
91106   }
91107   arg1 = *argp1;
91108   {
91109     try {
91110       result = Dali::Toolkit::PageTurnPortraitView::DownCast(arg1);
91111     } catch (std::out_of_range& e) {
91112       {
91113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91114       };
91115     } catch (std::exception& e) {
91116       {
91117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91118       };
91119     } catch (Dali::DaliException e) {
91120       {
91121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91122       };
91123     } catch (...) {
91124       {
91125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91126       };
91127     }
91128   }
91129
91130   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
91131   return jresult;
91132 }
91133
91134
91135 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_STATE_VISUALS_get() {
91136   int jresult ;
91137   int result;
91138
91139   result = (int)Dali::Toolkit::ToggleButton::Property::STATE_VISUALS;
91140   jresult = (int)result;
91141   return jresult;
91142 }
91143
91144
91145 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_TOOLTIPS_get() {
91146   int jresult ;
91147   int result;
91148
91149   result = (int)Dali::Toolkit::ToggleButton::Property::TOOLTIPS;
91150   jresult = (int)result;
91151   return jresult;
91152 }
91153
91154
91155 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_CURRENT_STATE_INDEX_get() {
91156   int jresult ;
91157   int result;
91158
91159   result = (int)Dali::Toolkit::ToggleButton::Property::CURRENT_STATE_INDEX;
91160   jresult = (int)result;
91161   return jresult;
91162 }
91163
91164
91165 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton_Property() {
91166   void * jresult ;
91167   Dali::Toolkit::ToggleButton::Property *result = 0 ;
91168
91169   {
91170     try {
91171       result = (Dali::Toolkit::ToggleButton::Property *)new Dali::Toolkit::ToggleButton::Property();
91172     } catch (std::out_of_range& e) {
91173       {
91174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91175       };
91176     } catch (std::exception& e) {
91177       {
91178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91179       };
91180     } catch (Dali::DaliException e) {
91181       {
91182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91183       };
91184     } catch (...) {
91185       {
91186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91187       };
91188     }
91189   }
91190
91191   jresult = (void *)result;
91192   return jresult;
91193 }
91194
91195
91196 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton_Property(void * jarg1) {
91197   Dali::Toolkit::ToggleButton::Property *arg1 = (Dali::Toolkit::ToggleButton::Property *) 0 ;
91198
91199   arg1 = (Dali::Toolkit::ToggleButton::Property *)jarg1;
91200   {
91201     try {
91202       delete arg1;
91203     } catch (std::out_of_range& e) {
91204       {
91205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91206       };
91207     } catch (std::exception& e) {
91208       {
91209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91210       };
91211     } catch (Dali::DaliException e) {
91212       {
91213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91214       };
91215     } catch (...) {
91216       {
91217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91218       };
91219     }
91220   }
91221
91222 }
91223
91224
91225 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_0() {
91226   void * jresult ;
91227   Dali::Toolkit::ToggleButton *result = 0 ;
91228
91229   {
91230     try {
91231       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton();
91232     } catch (std::out_of_range& e) {
91233       {
91234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91235       };
91236     } catch (std::exception& e) {
91237       {
91238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91239       };
91240     } catch (Dali::DaliException e) {
91241       {
91242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91243       };
91244     } catch (...) {
91245       {
91246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91247       };
91248     }
91249   }
91250
91251   jresult = (void *)result;
91252   return jresult;
91253 }
91254
91255
91256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_1(void * jarg1) {
91257   void * jresult ;
91258   Dali::Toolkit::ToggleButton *arg1 = 0 ;
91259   Dali::Toolkit::ToggleButton *result = 0 ;
91260
91261   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
91262   if (!arg1) {
91263     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
91264     return 0;
91265   }
91266   {
91267     try {
91268       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton((Dali::Toolkit::ToggleButton const &)*arg1);
91269     } catch (std::out_of_range& e) {
91270       {
91271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91272       };
91273     } catch (std::exception& e) {
91274       {
91275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91276       };
91277     } catch (Dali::DaliException e) {
91278       {
91279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91280       };
91281     } catch (...) {
91282       {
91283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91284       };
91285     }
91286   }
91287
91288   jresult = (void *)result;
91289   return jresult;
91290 }
91291
91292
91293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_Assign(void * jarg1, void * jarg2) {
91294   void * jresult ;
91295   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
91296   Dali::Toolkit::ToggleButton *arg2 = 0 ;
91297   Dali::Toolkit::ToggleButton *result = 0 ;
91298
91299   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
91300   arg2 = (Dali::Toolkit::ToggleButton *)jarg2;
91301   if (!arg2) {
91302     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
91303     return 0;
91304   }
91305   {
91306     try {
91307       result = (Dali::Toolkit::ToggleButton *) &(arg1)->operator =((Dali::Toolkit::ToggleButton const &)*arg2);
91308     } catch (std::out_of_range& e) {
91309       {
91310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91311       };
91312     } catch (std::exception& e) {
91313       {
91314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91315       };
91316     } catch (Dali::DaliException e) {
91317       {
91318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91319       };
91320     } catch (...) {
91321       {
91322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91323       };
91324     }
91325   }
91326
91327   jresult = (void *)result;
91328   return jresult;
91329 }
91330
91331
91332 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton(void * jarg1) {
91333   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
91334
91335   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
91336   {
91337     try {
91338       delete arg1;
91339     } catch (std::out_of_range& e) {
91340       {
91341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91342       };
91343     } catch (std::exception& e) {
91344       {
91345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91346       };
91347     } catch (Dali::DaliException e) {
91348       {
91349         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91350       };
91351     } catch (...) {
91352       {
91353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91354       };
91355     }
91356   }
91357
91358 }
91359
91360
91361 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_New() {
91362   void * jresult ;
91363   Dali::Toolkit::ToggleButton result;
91364
91365   {
91366     try {
91367       result = Dali::Toolkit::ToggleButton::New();
91368     } catch (std::out_of_range& e) {
91369       {
91370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91371       };
91372     } catch (std::exception& e) {
91373       {
91374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91375       };
91376     } catch (Dali::DaliException e) {
91377       {
91378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91379       };
91380     } catch (...) {
91381       {
91382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91383       };
91384     }
91385   }
91386
91387   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
91388   return jresult;
91389 }
91390
91391
91392 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_DownCast(void * jarg1) {
91393   void * jresult ;
91394   Dali::BaseHandle arg1 ;
91395   Dali::BaseHandle *argp1 ;
91396   Dali::Toolkit::ToggleButton result;
91397
91398   argp1 = (Dali::BaseHandle *)jarg1;
91399   if (!argp1) {
91400     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
91401     return 0;
91402   }
91403   arg1 = *argp1;
91404   {
91405     try {
91406       result = Dali::Toolkit::ToggleButton::DownCast(arg1);
91407     } catch (std::out_of_range& e) {
91408       {
91409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91410       };
91411     } catch (std::exception& e) {
91412       {
91413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91414       };
91415     } catch (Dali::DaliException e) {
91416       {
91417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91418       };
91419     } catch (...) {
91420       {
91421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91422       };
91423     }
91424   }
91425
91426   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
91427   return jresult;
91428 }
91429
91430
91431 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_0() {
91432   void * jresult ;
91433   Dali::Toolkit::Visual::Base *result = 0 ;
91434
91435   {
91436     try {
91437       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base();
91438     } catch (std::out_of_range& e) {
91439       {
91440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91441       };
91442     } catch (std::exception& e) {
91443       {
91444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91445       };
91446     } catch (Dali::DaliException e) {
91447       {
91448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91449       };
91450     } catch (...) {
91451       {
91452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91453       };
91454     }
91455   }
91456
91457   jresult = (void *)result;
91458   return jresult;
91459 }
91460
91461
91462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualBase(void * jarg1) {
91463   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91464
91465   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91466   {
91467     try {
91468       delete arg1;
91469     } catch (std::out_of_range& e) {
91470       {
91471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91472       };
91473     } catch (std::exception& e) {
91474       {
91475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91476       };
91477     } catch (Dali::DaliException e) {
91478       {
91479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91480       };
91481     } catch (...) {
91482       {
91483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91484       };
91485     }
91486   }
91487
91488 }
91489
91490
91491 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_1(void * jarg1) {
91492   void * jresult ;
91493   Dali::Toolkit::Visual::Base *arg1 = 0 ;
91494   Dali::Toolkit::Visual::Base *result = 0 ;
91495
91496   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91497   if (!arg1) {
91498     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
91499     return 0;
91500   }
91501   {
91502     try {
91503       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base((Dali::Toolkit::Visual::Base const &)*arg1);
91504     } catch (std::out_of_range& e) {
91505       {
91506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91507       };
91508     } catch (std::exception& e) {
91509       {
91510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91511       };
91512     } catch (Dali::DaliException e) {
91513       {
91514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91515       };
91516     } catch (...) {
91517       {
91518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91519       };
91520     }
91521   }
91522
91523   jresult = (void *)result;
91524   return jresult;
91525 }
91526
91527
91528 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualBase_Assign(void * jarg1, void * jarg2) {
91529   void * jresult ;
91530   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91531   Dali::Toolkit::Visual::Base *arg2 = 0 ;
91532   Dali::Toolkit::Visual::Base *result = 0 ;
91533
91534   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91535   arg2 = (Dali::Toolkit::Visual::Base *)jarg2;
91536   if (!arg2) {
91537     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
91538     return 0;
91539   }
91540   {
91541     try {
91542       result = (Dali::Toolkit::Visual::Base *) &(arg1)->operator =((Dali::Toolkit::Visual::Base const &)*arg2);
91543     } catch (std::out_of_range& e) {
91544       {
91545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91546       };
91547     } catch (std::exception& e) {
91548       {
91549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91550       };
91551     } catch (Dali::DaliException e) {
91552       {
91553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91554       };
91555     } catch (...) {
91556       {
91557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91558       };
91559     }
91560   }
91561
91562   jresult = (void *)result;
91563   return jresult;
91564 }
91565
91566
91567 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetName(void * jarg1, char * jarg2) {
91568   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91569   std::string *arg2 = 0 ;
91570
91571   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91572   if (!jarg2) {
91573     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91574     return ;
91575   }
91576   std::string arg2_str(jarg2);
91577   arg2 = &arg2_str;
91578   {
91579     try {
91580       (arg1)->SetName((std::string const &)*arg2);
91581     } catch (std::out_of_range& e) {
91582       {
91583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91584       };
91585     } catch (std::exception& e) {
91586       {
91587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91588       };
91589     } catch (Dali::DaliException e) {
91590       {
91591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91592       };
91593     } catch (...) {
91594       {
91595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91596       };
91597     }
91598   }
91599
91600
91601   //argout typemap for const std::string&
91602
91603 }
91604
91605
91606 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_VisualBase_GetName(void * jarg1) {
91607   char * jresult ;
91608   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91609   std::string *result = 0 ;
91610
91611   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91612   {
91613     try {
91614       result = (std::string *) &(arg1)->GetName();
91615     } catch (std::out_of_range& e) {
91616       {
91617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91618       };
91619     } catch (std::exception& e) {
91620       {
91621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91622       };
91623     } catch (Dali::DaliException e) {
91624       {
91625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91626       };
91627     } catch (...) {
91628       {
91629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91630       };
91631     }
91632   }
91633
91634   jresult = SWIG_csharp_string_callback(result->c_str());
91635   return jresult;
91636 }
91637
91638
91639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetTransformAndSize(void * jarg1, void * jarg2, void * jarg3) {
91640   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91641   Dali::Property::Map *arg2 = 0 ;
91642   Dali::Size arg3 ;
91643   Dali::Size *argp3 ;
91644
91645   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91646   arg2 = (Dali::Property::Map *)jarg2;
91647   if (!arg2) {
91648     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
91649     return ;
91650   }
91651   argp3 = (Dali::Size *)jarg3;
91652   if (!argp3) {
91653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
91654     return ;
91655   }
91656   arg3 = *argp3;
91657   {
91658     try {
91659       (arg1)->SetTransformAndSize((Dali::Property::Map const &)*arg2,arg3);
91660     } catch (std::out_of_range& e) {
91661       {
91662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91663       };
91664     } catch (std::exception& e) {
91665       {
91666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91667       };
91668     } catch (Dali::DaliException e) {
91669       {
91670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91671       };
91672     } catch (...) {
91673       {
91674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91675       };
91676     }
91677   }
91678
91679 }
91680
91681
91682 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetHeightForWidth(void * jarg1, float jarg2) {
91683   float jresult ;
91684   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91685   float arg2 ;
91686   float result;
91687
91688   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91689   arg2 = (float)jarg2;
91690   {
91691     try {
91692       result = (float)(arg1)->GetHeightForWidth(arg2);
91693     } catch (std::out_of_range& e) {
91694       {
91695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91696       };
91697     } catch (std::exception& e) {
91698       {
91699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91700       };
91701     } catch (Dali::DaliException e) {
91702       {
91703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91704       };
91705     } catch (...) {
91706       {
91707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91708       };
91709     }
91710   }
91711
91712   jresult = result;
91713   return jresult;
91714 }
91715
91716
91717 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetWidthForHeight(void * jarg1, float jarg2) {
91718   float jresult ;
91719   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91720   float arg2 ;
91721   float result;
91722
91723   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91724   arg2 = (float)jarg2;
91725   {
91726     try {
91727       result = (float)(arg1)->GetWidthForHeight(arg2);
91728     } catch (std::out_of_range& e) {
91729       {
91730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91731       };
91732     } catch (std::exception& e) {
91733       {
91734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91735       };
91736     } catch (Dali::DaliException e) {
91737       {
91738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91739       };
91740     } catch (...) {
91741       {
91742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91743       };
91744     }
91745   }
91746
91747   jresult = result;
91748   return jresult;
91749 }
91750
91751
91752 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_GetNaturalSize(void * jarg1, void * jarg2) {
91753   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91754   Dali::Vector2 *arg2 = 0 ;
91755
91756   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91757   arg2 = (Dali::Vector2 *)jarg2;
91758   if (!arg2) {
91759     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
91760     return ;
91761   }
91762   {
91763     try {
91764       (arg1)->GetNaturalSize(*arg2);
91765     } catch (std::out_of_range& e) {
91766       {
91767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91768       };
91769     } catch (std::exception& e) {
91770       {
91771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91772       };
91773     } catch (Dali::DaliException e) {
91774       {
91775         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91776       };
91777     } catch (...) {
91778       {
91779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91780       };
91781     }
91782   }
91783
91784 }
91785
91786
91787 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetDepthIndex(void * jarg1, int jarg2) {
91788   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91789   float arg2 ;
91790
91791   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91792   arg2 = (int)jarg2;
91793   {
91794     try {
91795       (arg1)->SetDepthIndex(arg2);
91796     } catch (std::out_of_range& e) {
91797       {
91798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91799       };
91800     } catch (std::exception& e) {
91801       {
91802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91803       };
91804     } catch (Dali::DaliException e) {
91805       {
91806         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91807       };
91808     } catch (...) {
91809       {
91810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91811       };
91812     }
91813   }
91814
91815 }
91816
91817
91818 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VisualBase_GetDepthIndex(void * jarg1) {
91819   int jresult ;
91820   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91821   int result;
91822
91823   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91824   {
91825     try {
91826       result = (float)((Dali::Toolkit::Visual::Base const *)arg1)->GetDepthIndex();
91827     } catch (std::out_of_range& e) {
91828       {
91829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91830       };
91831     } catch (std::exception& e) {
91832       {
91833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91834       };
91835     } catch (Dali::DaliException e) {
91836       {
91837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91838       };
91839     } catch (...) {
91840       {
91841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91842       };
91843     }
91844   }
91845
91846   jresult = result;
91847   return jresult;
91848 }
91849
91850
91851 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_CreatePropertyMap(void * jarg1, void * jarg2) {
91852   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91853   Dali::Property::Map *arg2 = 0 ;
91854
91855   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91856   arg2 = (Dali::Property::Map *)jarg2;
91857   if (!arg2) {
91858     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
91859     return ;
91860   }
91861   {
91862     try {
91863       ((Dali::Toolkit::Visual::Base const *)arg1)->CreatePropertyMap(*arg2);
91864     } catch (std::out_of_range& e) {
91865       {
91866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91867       };
91868     } catch (std::exception& e) {
91869       {
91870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91871       };
91872     } catch (Dali::DaliException e) {
91873       {
91874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91875       };
91876     } catch (...) {
91877       {
91878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91879       };
91880     }
91881   }
91882
91883 }
91884
91885
91886 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_2(void * jarg1) {
91887   void * jresult ;
91888   Dali::Toolkit::Internal::Visual::Base *arg1 = (Dali::Toolkit::Internal::Visual::Base *) 0 ;
91889   Dali::Toolkit::Visual::Base *result = 0 ;
91890
91891   arg1 = (Dali::Toolkit::Internal::Visual::Base *)jarg1;
91892   {
91893     try {
91894       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base(arg1);
91895     } catch (std::out_of_range& e) {
91896       {
91897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91898       };
91899     } catch (std::exception& e) {
91900       {
91901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91902       };
91903     } catch (Dali::DaliException e) {
91904       {
91905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91906       };
91907     } catch (...) {
91908       {
91909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91910       };
91911     }
91912   }
91913
91914   jresult = (void *)result;
91915   return jresult;
91916 }
91917
91918
91919 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Get() {
91920   void * jresult ;
91921   Dali::Toolkit::VisualFactory result;
91922
91923   {
91924     try {
91925       result = Dali::Toolkit::VisualFactory::Get();
91926     } catch (std::out_of_range& e) {
91927       {
91928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91929       };
91930     } catch (std::exception& e) {
91931       {
91932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91933       };
91934     } catch (Dali::DaliException e) {
91935       {
91936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91937       };
91938     } catch (...) {
91939       {
91940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91941       };
91942     }
91943   }
91944
91945   jresult = new Dali::Toolkit::VisualFactory((const Dali::Toolkit::VisualFactory &)result);
91946   return jresult;
91947 }
91948
91949
91950 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_0() {
91951   void * jresult ;
91952   Dali::Toolkit::VisualFactory *result = 0 ;
91953
91954   {
91955     try {
91956       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory();
91957     } catch (std::out_of_range& e) {
91958       {
91959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91960       };
91961     } catch (std::exception& e) {
91962       {
91963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91964       };
91965     } catch (Dali::DaliException e) {
91966       {
91967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91968       };
91969     } catch (...) {
91970       {
91971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91972       };
91973     }
91974   }
91975
91976   jresult = (void *)result;
91977   return jresult;
91978 }
91979
91980
91981 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualFactory(void * jarg1) {
91982   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91983
91984   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91985   {
91986     try {
91987       delete arg1;
91988     } catch (std::out_of_range& e) {
91989       {
91990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91991       };
91992     } catch (std::exception& e) {
91993       {
91994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91995       };
91996     } catch (Dali::DaliException e) {
91997       {
91998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91999       };
92000     } catch (...) {
92001       {
92002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92003       };
92004     }
92005   }
92006
92007 }
92008
92009
92010 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_1(void * jarg1) {
92011   void * jresult ;
92012   Dali::Toolkit::VisualFactory *arg1 = 0 ;
92013   Dali::Toolkit::VisualFactory *result = 0 ;
92014
92015   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
92016   if (!arg1) {
92017     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
92018     return 0;
92019   }
92020   {
92021     try {
92022       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory((Dali::Toolkit::VisualFactory const &)*arg1);
92023     } catch (std::out_of_range& e) {
92024       {
92025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92026       };
92027     } catch (std::exception& e) {
92028       {
92029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92030       };
92031     } catch (Dali::DaliException e) {
92032       {
92033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92034       };
92035     } catch (...) {
92036       {
92037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92038       };
92039     }
92040   }
92041
92042   jresult = (void *)result;
92043   return jresult;
92044 }
92045
92046
92047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Assign(void * jarg1, void * jarg2) {
92048   void * jresult ;
92049   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
92050   Dali::Toolkit::VisualFactory *arg2 = 0 ;
92051   Dali::Toolkit::VisualFactory *result = 0 ;
92052
92053   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
92054   arg2 = (Dali::Toolkit::VisualFactory *)jarg2;
92055   if (!arg2) {
92056     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
92057     return 0;
92058   }
92059   {
92060     try {
92061       result = (Dali::Toolkit::VisualFactory *) &(arg1)->operator =((Dali::Toolkit::VisualFactory const &)*arg2);
92062     } catch (std::out_of_range& e) {
92063       {
92064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92065       };
92066     } catch (std::exception& e) {
92067       {
92068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92069       };
92070     } catch (Dali::DaliException e) {
92071       {
92072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92073       };
92074     } catch (...) {
92075       {
92076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92077       };
92078     }
92079   }
92080
92081   jresult = (void *)result;
92082   return jresult;
92083 }
92084
92085
92086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_0(void * jarg1, void * jarg2) {
92087   void * jresult ;
92088   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
92089   Dali::Property::Map *arg2 = 0 ;
92090   Dali::Toolkit::Visual::Base result;
92091
92092   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
92093   arg2 = (Dali::Property::Map *)jarg2;
92094   if (!arg2) {
92095     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
92096     return 0;
92097   }
92098   {
92099     try {
92100       result = (arg1)->CreateVisual((Dali::Property::Map const &)*arg2);
92101     } catch (std::out_of_range& e) {
92102       {
92103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92104       };
92105     } catch (std::exception& e) {
92106       {
92107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92108       };
92109     } catch (Dali::DaliException e) {
92110       {
92111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92112       };
92113     } catch (...) {
92114       {
92115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92116       };
92117     }
92118   }
92119
92120   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
92121   return jresult;
92122 }
92123
92124
92125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_1(void * jarg1, void * jarg2) {
92126   void * jresult ;
92127   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
92128   Dali::Image *arg2 = 0 ;
92129   Dali::Toolkit::Visual::Base result;
92130
92131   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
92132   arg2 = (Dali::Image *)jarg2;
92133   if (!arg2) {
92134     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
92135     return 0;
92136   }
92137   {
92138     try {
92139       result = (arg1)->CreateVisual((Dali::Image const &)*arg2);
92140     } catch (std::out_of_range& e) {
92141       {
92142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92143       };
92144     } catch (std::exception& e) {
92145       {
92146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92147       };
92148     } catch (Dali::DaliException e) {
92149       {
92150         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92151       };
92152     } catch (...) {
92153       {
92154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92155       };
92156     }
92157   }
92158
92159   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
92160   return jresult;
92161 }
92162
92163
92164 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
92165   void * jresult ;
92166   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
92167   std::string *arg2 = 0 ;
92168   Dali::ImageDimensions arg3 ;
92169   Dali::ImageDimensions *argp3 ;
92170   Dali::Toolkit::Visual::Base result;
92171
92172   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
92173   if (!jarg2) {
92174     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92175     return 0;
92176   }
92177   std::string arg2_str(jarg2);
92178   arg2 = &arg2_str;
92179   argp3 = (Dali::ImageDimensions *)jarg3;
92180   if (!argp3) {
92181     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
92182     return 0;
92183   }
92184   arg3 = *argp3;
92185   {
92186     try {
92187       result = (arg1)->CreateVisual((std::string const &)*arg2,arg3);
92188     } catch (std::out_of_range& e) {
92189       {
92190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92191       };
92192     } catch (std::exception& e) {
92193       {
92194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92195       };
92196     } catch (Dali::DaliException e) {
92197       {
92198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92199       };
92200     } catch (...) {
92201       {
92202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92203       };
92204     }
92205   }
92206
92207   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
92208
92209   //argout typemap for const std::string&
92210
92211   return jresult;
92212 }
92213
92214
92215 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_0() {
92216   void * jresult ;
92217   Dali::Toolkit::AsyncImageLoader *result = 0 ;
92218
92219   {
92220     try {
92221       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader();
92222     } catch (std::out_of_range& e) {
92223       {
92224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92225       };
92226     } catch (std::exception& e) {
92227       {
92228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92229       };
92230     } catch (Dali::DaliException e) {
92231       {
92232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92233       };
92234     } catch (...) {
92235       {
92236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92237       };
92238     }
92239   }
92240
92241   jresult = (void *)result;
92242   return jresult;
92243 }
92244
92245
92246 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AsyncImageLoader(void * jarg1) {
92247   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92248
92249   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92250   {
92251     try {
92252       delete arg1;
92253     } catch (std::out_of_range& e) {
92254       {
92255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92256       };
92257     } catch (std::exception& e) {
92258       {
92259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92260       };
92261     } catch (Dali::DaliException e) {
92262       {
92263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92264       };
92265     } catch (...) {
92266       {
92267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92268       };
92269     }
92270   }
92271
92272 }
92273
92274
92275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_1(void * jarg1) {
92276   void * jresult ;
92277   Dali::Toolkit::AsyncImageLoader *arg1 = 0 ;
92278   Dali::Toolkit::AsyncImageLoader *result = 0 ;
92279
92280   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92281   if (!arg1) {
92282     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
92283     return 0;
92284   }
92285   {
92286     try {
92287       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader((Dali::Toolkit::AsyncImageLoader const &)*arg1);
92288     } catch (std::out_of_range& e) {
92289       {
92290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92291       };
92292     } catch (std::exception& e) {
92293       {
92294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92295       };
92296     } catch (Dali::DaliException e) {
92297       {
92298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92299       };
92300     } catch (...) {
92301       {
92302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92303       };
92304     }
92305   }
92306
92307   jresult = (void *)result;
92308   return jresult;
92309 }
92310
92311
92312 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Assign(void * jarg1, void * jarg2) {
92313   void * jresult ;
92314   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92315   Dali::Toolkit::AsyncImageLoader *arg2 = 0 ;
92316   Dali::Toolkit::AsyncImageLoader *result = 0 ;
92317
92318   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92319   arg2 = (Dali::Toolkit::AsyncImageLoader *)jarg2;
92320   if (!arg2) {
92321     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
92322     return 0;
92323   }
92324   {
92325     try {
92326       result = (Dali::Toolkit::AsyncImageLoader *) &(arg1)->operator =((Dali::Toolkit::AsyncImageLoader const &)*arg2);
92327     } catch (std::out_of_range& e) {
92328       {
92329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92330       };
92331     } catch (std::exception& e) {
92332       {
92333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92334       };
92335     } catch (Dali::DaliException e) {
92336       {
92337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92338       };
92339     } catch (...) {
92340       {
92341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92342       };
92343     }
92344   }
92345
92346   jresult = (void *)result;
92347   return jresult;
92348 }
92349
92350
92351 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_New() {
92352   void * jresult ;
92353   Dali::Toolkit::AsyncImageLoader result;
92354
92355   {
92356     try {
92357       result = Dali::Toolkit::AsyncImageLoader::New();
92358     } catch (std::out_of_range& e) {
92359       {
92360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92361       };
92362     } catch (std::exception& e) {
92363       {
92364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92365       };
92366     } catch (Dali::DaliException e) {
92367       {
92368         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92369       };
92370     } catch (...) {
92371       {
92372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92373       };
92374     }
92375   }
92376
92377   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
92378   return jresult;
92379 }
92380
92381
92382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_DownCast(void * jarg1) {
92383   void * jresult ;
92384   Dali::BaseHandle arg1 ;
92385   Dali::BaseHandle *argp1 ;
92386   Dali::Toolkit::AsyncImageLoader result;
92387
92388   argp1 = (Dali::BaseHandle *)jarg1;
92389   if (!argp1) {
92390     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
92391     return 0;
92392   }
92393   arg1 = *argp1;
92394   {
92395     try {
92396       result = Dali::Toolkit::AsyncImageLoader::DownCast(arg1);
92397     } catch (std::out_of_range& e) {
92398       {
92399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92400       };
92401     } catch (std::exception& e) {
92402       {
92403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92404       };
92405     } catch (Dali::DaliException e) {
92406       {
92407         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92408       };
92409     } catch (...) {
92410       {
92411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92412       };
92413     }
92414   }
92415
92416   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
92417   return jresult;
92418 }
92419
92420
92421 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_0(void * jarg1, char * jarg2) {
92422   unsigned int jresult ;
92423   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92424   std::string *arg2 = 0 ;
92425   uint32_t result;
92426
92427   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92428   if (!jarg2) {
92429     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92430     return 0;
92431   }
92432   std::string arg2_str(jarg2);
92433   arg2 = &arg2_str;
92434   {
92435     try {
92436       result = (arg1)->Load((std::string const &)*arg2);
92437     } catch (std::out_of_range& e) {
92438       {
92439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92440       };
92441     } catch (std::exception& e) {
92442       {
92443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92444       };
92445     } catch (Dali::DaliException e) {
92446       {
92447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92448       };
92449     } catch (...) {
92450       {
92451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92452       };
92453     }
92454   }
92455
92456   jresult = result;
92457
92458   //argout typemap for const std::string&
92459
92460   return jresult;
92461 }
92462
92463
92464 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
92465   unsigned int jresult ;
92466   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92467   std::string *arg2 = 0 ;
92468   Dali::ImageDimensions arg3 ;
92469   Dali::ImageDimensions *argp3 ;
92470   uint32_t result;
92471
92472   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92473   if (!jarg2) {
92474     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92475     return 0;
92476   }
92477   std::string arg2_str(jarg2);
92478   arg2 = &arg2_str;
92479   argp3 = (Dali::ImageDimensions *)jarg3;
92480   if (!argp3) {
92481     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
92482     return 0;
92483   }
92484   arg3 = *argp3;
92485   {
92486     try {
92487       result = (arg1)->Load((std::string const &)*arg2,arg3);
92488     } catch (std::out_of_range& e) {
92489       {
92490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92491       };
92492     } catch (std::exception& e) {
92493       {
92494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92495       };
92496     } catch (Dali::DaliException e) {
92497       {
92498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92499       };
92500     } catch (...) {
92501       {
92502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92503       };
92504     }
92505   }
92506
92507   jresult = result;
92508
92509   //argout typemap for const std::string&
92510
92511   return jresult;
92512 }
92513
92514
92515 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_2(void * jarg1, char * jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
92516   unsigned int jresult ;
92517   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92518   std::string *arg2 = 0 ;
92519   Dali::ImageDimensions arg3 ;
92520   Dali::FittingMode::Type arg4 ;
92521   Dali::SamplingMode::Type arg5 ;
92522   bool arg6 ;
92523   Dali::ImageDimensions *argp3 ;
92524   uint32_t result;
92525
92526   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92527   if (!jarg2) {
92528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92529     return 0;
92530   }
92531   std::string arg2_str(jarg2);
92532   arg2 = &arg2_str;
92533   argp3 = (Dali::ImageDimensions *)jarg3;
92534   if (!argp3) {
92535     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
92536     return 0;
92537   }
92538   arg3 = *argp3;
92539   arg4 = (Dali::FittingMode::Type)jarg4;
92540   arg5 = (Dali::SamplingMode::Type)jarg5;
92541   arg6 = jarg6 ? true : false;
92542   {
92543     try {
92544       result = (arg1)->Load((std::string const &)*arg2,arg3,arg4,arg5,arg6);
92545     } catch (std::out_of_range& e) {
92546       {
92547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92548       };
92549     } catch (std::exception& e) {
92550       {
92551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92552       };
92553     } catch (Dali::DaliException e) {
92554       {
92555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92556       };
92557     } catch (...) {
92558       {
92559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92560       };
92561     }
92562   }
92563
92564   jresult = result;
92565
92566   //argout typemap for const std::string&
92567
92568   return jresult;
92569 }
92570
92571
92572 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Cancel(void * jarg1, unsigned int jarg2) {
92573   unsigned int jresult ;
92574   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92575   uint32_t arg2 ;
92576   bool result;
92577
92578   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92579   arg2 = (uint32_t)jarg2;
92580   {
92581     try {
92582       result = (bool)(arg1)->Cancel(arg2);
92583     } catch (std::out_of_range& e) {
92584       {
92585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92586       };
92587     } catch (std::exception& e) {
92588       {
92589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92590       };
92591     } catch (Dali::DaliException e) {
92592       {
92593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92594       };
92595     } catch (...) {
92596       {
92597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92598       };
92599     }
92600   }
92601
92602   jresult = result;
92603   return jresult;
92604 }
92605
92606
92607 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AsyncImageLoader_CancelAll(void * jarg1) {
92608   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92609
92610   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92611   {
92612     try {
92613       (arg1)->CancelAll();
92614     } catch (std::out_of_range& e) {
92615       {
92616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92617       };
92618     } catch (std::exception& e) {
92619       {
92620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92621       };
92622     } catch (Dali::DaliException e) {
92623       {
92624         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92625       };
92626     } catch (...) {
92627       {
92628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92629       };
92630     }
92631   }
92632
92633 }
92634
92635
92636 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_ImageLoadedSignal(void * jarg1) {
92637   void * jresult ;
92638   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92639   Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *result = 0 ;
92640
92641   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92642   {
92643     try {
92644       result = (Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *) &(arg1)->ImageLoadedSignal();
92645     } catch (std::out_of_range& e) {
92646       {
92647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92648       };
92649     } catch (std::exception& e) {
92650       {
92651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92652       };
92653     } catch (Dali::DaliException e) {
92654       {
92655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92656       };
92657     } catch (...) {
92658       {
92659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92660       };
92661     }
92662   }
92663
92664   jresult = (void *)result;
92665   return jresult;
92666 }
92667
92668
92669 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_2(void * jarg1) {
92670   void * jresult ;
92671   Dali::Toolkit::Internal::AsyncImageLoader *arg1 = (Dali::Toolkit::Internal::AsyncImageLoader *) 0 ;
92672   Dali::Toolkit::AsyncImageLoader *result = 0 ;
92673
92674   arg1 = (Dali::Toolkit::Internal::AsyncImageLoader *)jarg1;
92675   {
92676     try {
92677       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader(arg1);
92678     } catch (std::out_of_range& e) {
92679       {
92680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92681       };
92682     } catch (std::exception& e) {
92683       {
92684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92685       };
92686     } catch (Dali::DaliException e) {
92687       {
92688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92689       };
92690     } catch (...) {
92691       {
92692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92693       };
92694     }
92695   }
92696
92697   jresult = (void *)result;
92698   return jresult;
92699 }
92700
92701
92702 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_0(char * jarg1) {
92703   void * jresult ;
92704   std::string *arg1 = 0 ;
92705   Dali::PixelData result;
92706
92707   if (!jarg1) {
92708     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92709     return 0;
92710   }
92711   std::string arg1_str(jarg1);
92712   arg1 = &arg1_str;
92713   {
92714     try {
92715       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1);
92716     } catch (std::out_of_range& e) {
92717       {
92718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92719       };
92720     } catch (std::exception& e) {
92721       {
92722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92723       };
92724     } catch (Dali::DaliException e) {
92725       {
92726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92727       };
92728     } catch (...) {
92729       {
92730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92731       };
92732     }
92733   }
92734
92735   jresult = new Dali::PixelData((const Dali::PixelData &)result);
92736
92737   //argout typemap for const std::string&
92738
92739   return jresult;
92740 }
92741
92742
92743 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_1(char * jarg1, void * jarg2) {
92744   void * jresult ;
92745   std::string *arg1 = 0 ;
92746   Dali::ImageDimensions arg2 ;
92747   Dali::ImageDimensions *argp2 ;
92748   Dali::PixelData result;
92749
92750   if (!jarg1) {
92751     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92752     return 0;
92753   }
92754   std::string arg1_str(jarg1);
92755   arg1 = &arg1_str;
92756   argp2 = (Dali::ImageDimensions *)jarg2;
92757   if (!argp2) {
92758     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
92759     return 0;
92760   }
92761   arg2 = *argp2;
92762   {
92763     try {
92764       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2);
92765     } catch (std::out_of_range& e) {
92766       {
92767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92768       };
92769     } catch (std::exception& e) {
92770       {
92771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92772       };
92773     } catch (Dali::DaliException e) {
92774       {
92775         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92776       };
92777     } catch (...) {
92778       {
92779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92780       };
92781     }
92782   }
92783
92784   jresult = new Dali::PixelData((const Dali::PixelData &)result);
92785
92786   //argout typemap for const std::string&
92787
92788   return jresult;
92789 }
92790
92791
92792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
92793   void * jresult ;
92794   std::string *arg1 = 0 ;
92795   Dali::ImageDimensions arg2 ;
92796   Dali::FittingMode::Type arg3 ;
92797   Dali::SamplingMode::Type arg4 ;
92798   bool arg5 ;
92799   Dali::ImageDimensions *argp2 ;
92800   Dali::PixelData result;
92801
92802   if (!jarg1) {
92803     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92804     return 0;
92805   }
92806   std::string arg1_str(jarg1);
92807   arg1 = &arg1_str;
92808   argp2 = (Dali::ImageDimensions *)jarg2;
92809   if (!argp2) {
92810     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
92811     return 0;
92812   }
92813   arg2 = *argp2;
92814   arg3 = (Dali::FittingMode::Type)jarg3;
92815   arg4 = (Dali::SamplingMode::Type)jarg4;
92816   arg5 = jarg5 ? true : false;
92817   {
92818     try {
92819       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2,arg3,arg4,arg5);
92820     } catch (std::out_of_range& e) {
92821       {
92822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92823       };
92824     } catch (std::exception& e) {
92825       {
92826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92827       };
92828     } catch (Dali::DaliException e) {
92829       {
92830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92831       };
92832     } catch (...) {
92833       {
92834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92835       };
92836     }
92837   }
92838
92839   jresult = new Dali::PixelData((const Dali::PixelData &)result);
92840
92841   //argout typemap for const std::string&
92842
92843   return jresult;
92844 }
92845
92846
92847 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomAlgorithmInterface(void * jarg1) {
92848   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
92849
92850   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
92851   {
92852     try {
92853       delete arg1;
92854     } catch (std::out_of_range& e) {
92855       {
92856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92857       };
92858     } catch (std::exception& e) {
92859       {
92860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92861       };
92862     } catch (Dali::DaliException e) {
92863       {
92864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92865       };
92866     } catch (...) {
92867       {
92868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92869       };
92870     }
92871   }
92872
92873 }
92874
92875
92876 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_GetNextFocusableActor(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
92877   void * jresult ;
92878   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
92879   Dali::Actor arg2 ;
92880   Dali::Actor arg3 ;
92881   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
92882   Dali::Actor *argp2 ;
92883   Dali::Actor *argp3 ;
92884   Dali::Actor result;
92885
92886   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
92887   argp2 = (Dali::Actor *)jarg2;
92888   if (!argp2) {
92889     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
92890     return 0;
92891   }
92892   arg2 = *argp2;
92893   argp3 = (Dali::Actor *)jarg3;
92894   if (!argp3) {
92895     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
92896     return 0;
92897   }
92898   arg3 = *argp3;
92899   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
92900   {
92901     try {
92902       result = (arg1)->GetNextFocusableActor(arg2,arg3,arg4);
92903     } catch (std::out_of_range& e) {
92904       {
92905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92906       };
92907     } catch (std::exception& e) {
92908       {
92909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92910       };
92911     } catch (Dali::DaliException e) {
92912       {
92913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92914       };
92915     } catch (...) {
92916       {
92917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92918       };
92919     }
92920   }
92921
92922   jresult = new Dali::Actor((const Dali::Actor &)result);
92923   return jresult;
92924 }
92925
92926
92927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomAlgorithmInterface() {
92928   void * jresult ;
92929   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *result = 0 ;
92930
92931   {
92932     try {
92933       result = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)new SwigDirector_CustomAlgorithmInterface();
92934     } catch (std::out_of_range& e) {
92935       {
92936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92937       };
92938     } catch (std::exception& e) {
92939       {
92940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92941       };
92942     } catch (Dali::DaliException e) {
92943       {
92944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92945       };
92946     } catch (...) {
92947       {
92948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92949       };
92950     }
92951   }
92952
92953   jresult = (void *)result;
92954   return jresult;
92955 }
92956
92957
92958 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_director_connect(void *objarg, SwigDirector_CustomAlgorithmInterface::SWIG_Callback0_t callback0) {
92959   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *obj = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)objarg;
92960   SwigDirector_CustomAlgorithmInterface *director = dynamic_cast<SwigDirector_CustomAlgorithmInterface *>(obj);
92961   if (director) {
92962     director->swig_connect_director(callback0);
92963   }
92964 }
92965
92966
92967 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetCustomAlgorithm(void * jarg1, void * jarg2) {
92968   KeyboardFocusManager arg1 ;
92969   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg2 = 0 ;
92970   KeyboardFocusManager *argp1 ;
92971
92972   argp1 = (KeyboardFocusManager *)jarg1;
92973   if (!argp1) {
92974     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
92975     return ;
92976   }
92977   arg1 = *argp1;
92978   arg2 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg2;
92979   if (!arg2) {
92980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface & type is null", 0);
92981     return ;
92982   }
92983   {
92984     try {
92985       Dali::Toolkit::DevelKeyboardFocusManager::SetCustomAlgorithm(arg1,*arg2);
92986     } catch (std::out_of_range& e) {
92987       {
92988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92989       };
92990     } catch (std::exception& e) {
92991       {
92992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92993       };
92994     } catch (Dali::DaliException e) {
92995       {
92996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92997       };
92998     } catch (...) {
92999       {
93000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93001       };
93002     }
93003   }
93004
93005 }
93006
93007
93008 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Clear(void * jarg1) {
93009   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93010
93011   arg1 = (std::vector< unsigned int > *)jarg1;
93012   {
93013     try {
93014       (arg1)->clear();
93015     } catch (std::out_of_range& e) {
93016       {
93017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93018       };
93019     } catch (std::exception& e) {
93020       {
93021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93022       };
93023     } catch (Dali::DaliException e) {
93024       {
93025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93026       };
93027     } catch (...) {
93028       {
93029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93030       };
93031     }
93032   }
93033
93034 }
93035
93036
93037 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Add(void * jarg1, unsigned int jarg2) {
93038   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93039   unsigned int *arg2 = 0 ;
93040   unsigned int temp2 ;
93041
93042   arg1 = (std::vector< unsigned int > *)jarg1;
93043   temp2 = (unsigned int)jarg2;
93044   arg2 = &temp2;
93045   {
93046     try {
93047       (arg1)->push_back((unsigned int const &)*arg2);
93048     } catch (std::out_of_range& e) {
93049       {
93050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93051       };
93052     } catch (std::exception& e) {
93053       {
93054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93055       };
93056     } catch (Dali::DaliException e) {
93057       {
93058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93059       };
93060     } catch (...) {
93061       {
93062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93063       };
93064     }
93065   }
93066
93067 }
93068
93069
93070 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_size(void * jarg1) {
93071   unsigned long jresult ;
93072   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93073   std::vector< unsigned int >::size_type result;
93074
93075   arg1 = (std::vector< unsigned int > *)jarg1;
93076   {
93077     try {
93078       result = ((std::vector< unsigned int > const *)arg1)->size();
93079     } catch (std::out_of_range& e) {
93080       {
93081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93082       };
93083     } catch (std::exception& e) {
93084       {
93085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93086       };
93087     } catch (Dali::DaliException e) {
93088       {
93089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93090       };
93091     } catch (...) {
93092       {
93093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93094       };
93095     }
93096   }
93097
93098   jresult = (unsigned long)result;
93099   return jresult;
93100 }
93101
93102
93103 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_capacity(void * jarg1) {
93104   unsigned long jresult ;
93105   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93106   std::vector< unsigned int >::size_type result;
93107
93108   arg1 = (std::vector< unsigned int > *)jarg1;
93109   {
93110     try {
93111       result = ((std::vector< unsigned int > const *)arg1)->capacity();
93112     } catch (std::out_of_range& e) {
93113       {
93114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93115       };
93116     } catch (std::exception& e) {
93117       {
93118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93119       };
93120     } catch (Dali::DaliException e) {
93121       {
93122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93123       };
93124     } catch (...) {
93125       {
93126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93127       };
93128     }
93129   }
93130
93131   jresult = (unsigned long)result;
93132   return jresult;
93133 }
93134
93135
93136 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_reserve(void * jarg1, unsigned long jarg2) {
93137   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93138   std::vector< unsigned int >::size_type arg2 ;
93139
93140   arg1 = (std::vector< unsigned int > *)jarg1;
93141   arg2 = (std::vector< unsigned int >::size_type)jarg2;
93142   {
93143     try {
93144       (arg1)->reserve(arg2);
93145     } catch (std::out_of_range& e) {
93146       {
93147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93148       };
93149     } catch (std::exception& e) {
93150       {
93151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93152       };
93153     } catch (Dali::DaliException e) {
93154       {
93155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93156       };
93157     } catch (...) {
93158       {
93159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93160       };
93161     }
93162   }
93163
93164 }
93165
93166
93167 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_0() {
93168   void * jresult ;
93169   std::vector< unsigned int > *result = 0 ;
93170
93171   {
93172     try {
93173       result = (std::vector< unsigned int > *)new std::vector< unsigned int >();
93174     } catch (std::out_of_range& e) {
93175       {
93176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93177       };
93178     } catch (std::exception& e) {
93179       {
93180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93181       };
93182     } catch (Dali::DaliException e) {
93183       {
93184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93185       };
93186     } catch (...) {
93187       {
93188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93189       };
93190     }
93191   }
93192
93193   jresult = (void *)result;
93194   return jresult;
93195 }
93196
93197
93198 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_1(void * jarg1) {
93199   void * jresult ;
93200   std::vector< unsigned int > *arg1 = 0 ;
93201   std::vector< unsigned int > *result = 0 ;
93202
93203   arg1 = (std::vector< unsigned int > *)jarg1;
93204   if (!arg1) {
93205     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
93206     return 0;
93207   }
93208   {
93209     try {
93210       result = (std::vector< unsigned int > *)new std::vector< unsigned int >((std::vector< unsigned int > const &)*arg1);
93211     } catch (std::out_of_range& e) {
93212       {
93213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93214       };
93215     } catch (std::exception& e) {
93216       {
93217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93218       };
93219     } catch (Dali::DaliException e) {
93220       {
93221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93222       };
93223     } catch (...) {
93224       {
93225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93226       };
93227     }
93228   }
93229
93230   jresult = (void *)result;
93231   return jresult;
93232 }
93233
93234
93235 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_2(int jarg1) {
93236   void * jresult ;
93237   int arg1 ;
93238   std::vector< unsigned int > *result = 0 ;
93239
93240   arg1 = (int)jarg1;
93241   {
93242     try {
93243       try {
93244         result = (std::vector< unsigned int > *)new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(arg1);
93245       }
93246       catch(std::out_of_range &_e) {
93247         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93248         return 0;
93249       }
93250
93251     } catch (std::out_of_range& e) {
93252       {
93253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93254       };
93255     } catch (std::exception& e) {
93256       {
93257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93258       };
93259     } catch (Dali::DaliException e) {
93260       {
93261         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93262       };
93263     } catch (...) {
93264       {
93265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93266       };
93267     }
93268   }
93269
93270   jresult = (void *)result;
93271   return jresult;
93272 }
93273
93274
93275 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitemcopy(void * jarg1, int jarg2) {
93276   unsigned int jresult ;
93277   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93278   int arg2 ;
93279   unsigned int result;
93280
93281   arg1 = (std::vector< unsigned int > *)jarg1;
93282   arg2 = (int)jarg2;
93283   {
93284     try {
93285       try {
93286         result = (unsigned int)std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(arg1,arg2);
93287       }
93288       catch(std::out_of_range &_e) {
93289         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93290         return 0;
93291       }
93292
93293     } catch (std::out_of_range& e) {
93294       {
93295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93296       };
93297     } catch (std::exception& e) {
93298       {
93299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93300       };
93301     } catch (Dali::DaliException e) {
93302       {
93303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93304       };
93305     } catch (...) {
93306       {
93307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93308       };
93309     }
93310   }
93311
93312   jresult = result;
93313   return jresult;
93314 }
93315
93316
93317 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitem(void * jarg1, int jarg2) {
93318   unsigned int jresult ;
93319   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93320   int arg2 ;
93321   unsigned int *result = 0 ;
93322
93323   arg1 = (std::vector< unsigned int > *)jarg1;
93324   arg2 = (int)jarg2;
93325   {
93326     try {
93327       try {
93328         result = (unsigned int *) &std_vector_Sl_unsigned_SS_int_Sg__getitem(arg1,arg2);
93329       }
93330       catch(std::out_of_range &_e) {
93331         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93332         return 0;
93333       }
93334
93335     } catch (std::out_of_range& e) {
93336       {
93337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93338       };
93339     } catch (std::exception& e) {
93340       {
93341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93342       };
93343     } catch (Dali::DaliException e) {
93344       {
93345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93346       };
93347     } catch (...) {
93348       {
93349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93350       };
93351     }
93352   }
93353
93354   jresult = *result;
93355   return jresult;
93356 }
93357
93358
93359 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_setitem(void * jarg1, int jarg2, unsigned int jarg3) {
93360   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93361   int arg2 ;
93362   unsigned int *arg3 = 0 ;
93363   unsigned int temp3 ;
93364
93365   arg1 = (std::vector< unsigned int > *)jarg1;
93366   arg2 = (int)jarg2;
93367   temp3 = (unsigned int)jarg3;
93368   arg3 = &temp3;
93369   {
93370     try {
93371       try {
93372         std_vector_Sl_unsigned_SS_int_Sg__setitem(arg1,arg2,(unsigned int const &)*arg3);
93373       }
93374       catch(std::out_of_range &_e) {
93375         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93376         return ;
93377       }
93378
93379     } catch (std::out_of_range& e) {
93380       {
93381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93382       };
93383     } catch (std::exception& e) {
93384       {
93385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93386       };
93387     } catch (Dali::DaliException e) {
93388       {
93389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93390       };
93391     } catch (...) {
93392       {
93393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93394       };
93395     }
93396   }
93397
93398 }
93399
93400
93401 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_AddRange(void * jarg1, void * jarg2) {
93402   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93403   std::vector< unsigned int > *arg2 = 0 ;
93404
93405   arg1 = (std::vector< unsigned int > *)jarg1;
93406   arg2 = (std::vector< unsigned int > *)jarg2;
93407   if (!arg2) {
93408     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
93409     return ;
93410   }
93411   {
93412     try {
93413       std_vector_Sl_unsigned_SS_int_Sg__AddRange(arg1,(std::vector< unsigned int > const &)*arg2);
93414     } catch (std::out_of_range& e) {
93415       {
93416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93417       };
93418     } catch (std::exception& e) {
93419       {
93420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93421       };
93422     } catch (Dali::DaliException e) {
93423       {
93424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93425       };
93426     } catch (...) {
93427       {
93428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93429       };
93430     }
93431   }
93432
93433 }
93434
93435
93436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
93437   void * jresult ;
93438   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93439   int arg2 ;
93440   int arg3 ;
93441   std::vector< unsigned int > *result = 0 ;
93442
93443   arg1 = (std::vector< unsigned int > *)jarg1;
93444   arg2 = (int)jarg2;
93445   arg3 = (int)jarg3;
93446   {
93447     try {
93448       try {
93449         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__GetRange(arg1,arg2,arg3);
93450       }
93451       catch(std::out_of_range &_e) {
93452         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93453         return 0;
93454       }
93455       catch(std::invalid_argument &_e) {
93456         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
93457         return 0;
93458       }
93459
93460     } catch (std::out_of_range& e) {
93461       {
93462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93463       };
93464     } catch (std::exception& e) {
93465       {
93466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93467       };
93468     } catch (Dali::DaliException e) {
93469       {
93470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93471       };
93472     } catch (...) {
93473       {
93474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93475       };
93476     }
93477   }
93478
93479   jresult = (void *)result;
93480   return jresult;
93481 }
93482
93483
93484 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Insert(void * jarg1, int jarg2, unsigned int jarg3) {
93485   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93486   int arg2 ;
93487   unsigned int *arg3 = 0 ;
93488   unsigned int temp3 ;
93489
93490   arg1 = (std::vector< unsigned int > *)jarg1;
93491   arg2 = (int)jarg2;
93492   temp3 = (unsigned int)jarg3;
93493   arg3 = &temp3;
93494   {
93495     try {
93496       try {
93497         std_vector_Sl_unsigned_SS_int_Sg__Insert(arg1,arg2,(unsigned int const &)*arg3);
93498       }
93499       catch(std::out_of_range &_e) {
93500         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93501         return ;
93502       }
93503
93504     } catch (std::out_of_range& e) {
93505       {
93506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93507       };
93508     } catch (std::exception& e) {
93509       {
93510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93511       };
93512     } catch (Dali::DaliException e) {
93513       {
93514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93515       };
93516     } catch (...) {
93517       {
93518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93519       };
93520     }
93521   }
93522
93523 }
93524
93525
93526 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
93527   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93528   int arg2 ;
93529   std::vector< unsigned int > *arg3 = 0 ;
93530
93531   arg1 = (std::vector< unsigned int > *)jarg1;
93532   arg2 = (int)jarg2;
93533   arg3 = (std::vector< unsigned int > *)jarg3;
93534   if (!arg3) {
93535     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
93536     return ;
93537   }
93538   {
93539     try {
93540       try {
93541         std_vector_Sl_unsigned_SS_int_Sg__InsertRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
93542       }
93543       catch(std::out_of_range &_e) {
93544         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93545         return ;
93546       }
93547
93548     } catch (std::out_of_range& e) {
93549       {
93550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93551       };
93552     } catch (std::exception& e) {
93553       {
93554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93555       };
93556     } catch (Dali::DaliException e) {
93557       {
93558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93559       };
93560     } catch (...) {
93561       {
93562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93563       };
93564     }
93565   }
93566
93567 }
93568
93569
93570 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveAt(void * jarg1, int jarg2) {
93571   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93572   int arg2 ;
93573
93574   arg1 = (std::vector< unsigned int > *)jarg1;
93575   arg2 = (int)jarg2;
93576   {
93577     try {
93578       try {
93579         std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(arg1,arg2);
93580       }
93581       catch(std::out_of_range &_e) {
93582         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93583         return ;
93584       }
93585
93586     } catch (std::out_of_range& e) {
93587       {
93588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93589       };
93590     } catch (std::exception& e) {
93591       {
93592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93593       };
93594     } catch (Dali::DaliException e) {
93595       {
93596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93597       };
93598     } catch (...) {
93599       {
93600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93601       };
93602     }
93603   }
93604
93605 }
93606
93607
93608 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
93609   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93610   int arg2 ;
93611   int arg3 ;
93612
93613   arg1 = (std::vector< unsigned int > *)jarg1;
93614   arg2 = (int)jarg2;
93615   arg3 = (int)jarg3;
93616   {
93617     try {
93618       try {
93619         std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(arg1,arg2,arg3);
93620       }
93621       catch(std::out_of_range &_e) {
93622         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93623         return ;
93624       }
93625       catch(std::invalid_argument &_e) {
93626         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
93627         return ;
93628       }
93629
93630     } catch (std::out_of_range& e) {
93631       {
93632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93633       };
93634     } catch (std::exception& e) {
93635       {
93636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93637       };
93638     } catch (Dali::DaliException e) {
93639       {
93640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93641       };
93642     } catch (...) {
93643       {
93644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93645       };
93646     }
93647   }
93648
93649 }
93650
93651
93652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_Repeat(unsigned int jarg1, int jarg2) {
93653   void * jresult ;
93654   unsigned int *arg1 = 0 ;
93655   int arg2 ;
93656   unsigned int temp1 ;
93657   std::vector< unsigned int > *result = 0 ;
93658
93659   temp1 = (unsigned int)jarg1;
93660   arg1 = &temp1;
93661   arg2 = (int)jarg2;
93662   {
93663     try {
93664       try {
93665         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__Repeat((unsigned int const &)*arg1,arg2);
93666       }
93667       catch(std::out_of_range &_e) {
93668         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93669         return 0;
93670       }
93671
93672     } catch (std::out_of_range& e) {
93673       {
93674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93675       };
93676     } catch (std::exception& e) {
93677       {
93678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93679       };
93680     } catch (Dali::DaliException e) {
93681       {
93682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93683       };
93684     } catch (...) {
93685       {
93686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93687       };
93688     }
93689   }
93690
93691   jresult = (void *)result;
93692   return jresult;
93693 }
93694
93695
93696 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_0(void * jarg1) {
93697   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93698
93699   arg1 = (std::vector< unsigned int > *)jarg1;
93700   {
93701     try {
93702       std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(arg1);
93703     } catch (std::out_of_range& e) {
93704       {
93705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93706       };
93707     } catch (std::exception& e) {
93708       {
93709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93710       };
93711     } catch (Dali::DaliException e) {
93712       {
93713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93714       };
93715     } catch (...) {
93716       {
93717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93718       };
93719     }
93720   }
93721
93722 }
93723
93724
93725 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
93726   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93727   int arg2 ;
93728   int arg3 ;
93729
93730   arg1 = (std::vector< unsigned int > *)jarg1;
93731   arg2 = (int)jarg2;
93732   arg3 = (int)jarg3;
93733   {
93734     try {
93735       try {
93736         std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
93737       }
93738       catch(std::out_of_range &_e) {
93739         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93740         return ;
93741       }
93742       catch(std::invalid_argument &_e) {
93743         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
93744         return ;
93745       }
93746
93747     } catch (std::out_of_range& e) {
93748       {
93749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93750       };
93751     } catch (std::exception& e) {
93752       {
93753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93754       };
93755     } catch (Dali::DaliException e) {
93756       {
93757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93758       };
93759     } catch (...) {
93760       {
93761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93762       };
93763     }
93764   }
93765
93766 }
93767
93768
93769 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
93770   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93771   int arg2 ;
93772   std::vector< unsigned int > *arg3 = 0 ;
93773
93774   arg1 = (std::vector< unsigned int > *)jarg1;
93775   arg2 = (int)jarg2;
93776   arg3 = (std::vector< unsigned int > *)jarg3;
93777   if (!arg3) {
93778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
93779     return ;
93780   }
93781   {
93782     try {
93783       try {
93784         std_vector_Sl_unsigned_SS_int_Sg__SetRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
93785       }
93786       catch(std::out_of_range &_e) {
93787         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93788         return ;
93789       }
93790
93791     } catch (std::out_of_range& e) {
93792       {
93793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93794       };
93795     } catch (std::exception& e) {
93796       {
93797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93798       };
93799     } catch (Dali::DaliException e) {
93800       {
93801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93802       };
93803     } catch (...) {
93804       {
93805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93806       };
93807     }
93808   }
93809
93810 }
93811
93812
93813 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Contains(void * jarg1, unsigned int jarg2) {
93814   unsigned int jresult ;
93815   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93816   unsigned int *arg2 = 0 ;
93817   unsigned int temp2 ;
93818   bool result;
93819
93820   arg1 = (std::vector< unsigned int > *)jarg1;
93821   temp2 = (unsigned int)jarg2;
93822   arg2 = &temp2;
93823   {
93824     try {
93825       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Contains(arg1,(unsigned int const &)*arg2);
93826     } catch (std::out_of_range& e) {
93827       {
93828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93829       };
93830     } catch (std::exception& e) {
93831       {
93832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93833       };
93834     } catch (Dali::DaliException e) {
93835       {
93836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93837       };
93838     } catch (...) {
93839       {
93840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93841       };
93842     }
93843   }
93844
93845   jresult = result;
93846   return jresult;
93847 }
93848
93849
93850 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_IndexOf(void * jarg1, unsigned int jarg2) {
93851   int jresult ;
93852   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93853   unsigned int *arg2 = 0 ;
93854   unsigned int temp2 ;
93855   int result;
93856
93857   arg1 = (std::vector< unsigned int > *)jarg1;
93858   temp2 = (unsigned int)jarg2;
93859   arg2 = &temp2;
93860   {
93861     try {
93862       result = (int)std_vector_Sl_unsigned_SS_int_Sg__IndexOf(arg1,(unsigned int const &)*arg2);
93863     } catch (std::out_of_range& e) {
93864       {
93865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93866       };
93867     } catch (std::exception& e) {
93868       {
93869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93870       };
93871     } catch (Dali::DaliException e) {
93872       {
93873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93874       };
93875     } catch (...) {
93876       {
93877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93878       };
93879     }
93880   }
93881
93882   jresult = result;
93883   return jresult;
93884 }
93885
93886
93887 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_LastIndexOf(void * jarg1, unsigned int jarg2) {
93888   int jresult ;
93889   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93890   unsigned int *arg2 = 0 ;
93891   unsigned int temp2 ;
93892   int result;
93893
93894   arg1 = (std::vector< unsigned int > *)jarg1;
93895   temp2 = (unsigned int)jarg2;
93896   arg2 = &temp2;
93897   {
93898     try {
93899       result = (int)std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(arg1,(unsigned int const &)*arg2);
93900     } catch (std::out_of_range& e) {
93901       {
93902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93903       };
93904     } catch (std::exception& e) {
93905       {
93906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93907       };
93908     } catch (Dali::DaliException e) {
93909       {
93910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93911       };
93912     } catch (...) {
93913       {
93914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93915       };
93916     }
93917   }
93918
93919   jresult = result;
93920   return jresult;
93921 }
93922
93923
93924 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Remove(void * jarg1, unsigned int jarg2) {
93925   unsigned int jresult ;
93926   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93927   unsigned int *arg2 = 0 ;
93928   unsigned int temp2 ;
93929   bool result;
93930
93931   arg1 = (std::vector< unsigned int > *)jarg1;
93932   temp2 = (unsigned int)jarg2;
93933   arg2 = &temp2;
93934   {
93935     try {
93936       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Remove(arg1,(unsigned int const &)*arg2);
93937     } catch (std::out_of_range& e) {
93938       {
93939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93940       };
93941     } catch (std::exception& e) {
93942       {
93943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93944       };
93945     } catch (Dali::DaliException e) {
93946       {
93947         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93948       };
93949     } catch (...) {
93950       {
93951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93952       };
93953     }
93954   }
93955
93956   jresult = result;
93957   return jresult;
93958 }
93959
93960
93961 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemIdContainer(void * jarg1) {
93962   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93963
93964   arg1 = (std::vector< unsigned int > *)jarg1;
93965   {
93966     try {
93967       delete arg1;
93968     } catch (std::out_of_range& e) {
93969       {
93970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93971       };
93972     } catch (std::exception& e) {
93973       {
93974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93975       };
93976     } catch (Dali::DaliException e) {
93977       {
93978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93979       };
93980     } catch (...) {
93981       {
93982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93983       };
93984     }
93985   }
93986
93987 }
93988
93989
93990 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_0() {
93991   void * jresult ;
93992   std::pair< unsigned int,Dali::Actor > *result = 0 ;
93993
93994   {
93995     try {
93996       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >();
93997     } catch (std::out_of_range& e) {
93998       {
93999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94000       };
94001     } catch (std::exception& e) {
94002       {
94003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94004       };
94005     } catch (Dali::DaliException e) {
94006       {
94007         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94008       };
94009     } catch (...) {
94010       {
94011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94012       };
94013     }
94014   }
94015
94016   jresult = (void *)result;
94017   return jresult;
94018 }
94019
94020
94021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_1(unsigned int jarg1, void * jarg2) {
94022   void * jresult ;
94023   unsigned int arg1 ;
94024   Dali::Actor arg2 ;
94025   Dali::Actor *argp2 ;
94026   std::pair< unsigned int,Dali::Actor > *result = 0 ;
94027
94028   arg1 = (unsigned int)jarg1;
94029   argp2 = (Dali::Actor *)jarg2;
94030   if (!argp2) {
94031     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
94032     return 0;
94033   }
94034   arg2 = *argp2;
94035   {
94036     try {
94037       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >(arg1,arg2);
94038     } catch (std::out_of_range& e) {
94039       {
94040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94041       };
94042     } catch (std::exception& e) {
94043       {
94044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94045       };
94046     } catch (Dali::DaliException e) {
94047       {
94048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94049       };
94050     } catch (...) {
94051       {
94052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94053       };
94054     }
94055   }
94056
94057   jresult = (void *)result;
94058   return jresult;
94059 }
94060
94061
94062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_2(void * jarg1) {
94063   void * jresult ;
94064   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
94065   std::pair< unsigned int,Dali::Actor > *result = 0 ;
94066
94067   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
94068   if (!arg1) {
94069     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
94070     return 0;
94071   }
94072   {
94073     try {
94074       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >((std::pair< unsigned int,Dali::Actor > const &)*arg1);
94075     } catch (std::out_of_range& e) {
94076       {
94077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94078       };
94079     } catch (std::exception& e) {
94080       {
94081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94082       };
94083     } catch (Dali::DaliException e) {
94084       {
94085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94086       };
94087     } catch (...) {
94088       {
94089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94090       };
94091     }
94092   }
94093
94094   jresult = (void *)result;
94095   return jresult;
94096 }
94097
94098
94099 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_first_set(void * jarg1, unsigned int jarg2) {
94100   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
94101   unsigned int arg2 ;
94102
94103   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
94104   arg2 = (unsigned int)jarg2;
94105   if (arg1) (arg1)->first = arg2;
94106 }
94107
94108
94109 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Item_first_get(void * jarg1) {
94110   unsigned int jresult ;
94111   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
94112   unsigned int result;
94113
94114   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
94115   result = (unsigned int) ((arg1)->first);
94116   jresult = result;
94117   return jresult;
94118 }
94119
94120
94121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_second_set(void * jarg1, void * jarg2) {
94122   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
94123   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
94124
94125   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
94126   arg2 = (Dali::Actor *)jarg2;
94127   if (arg1) (arg1)->second = *arg2;
94128 }
94129
94130
94131 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Item_second_get(void * jarg1) {
94132   void * jresult ;
94133   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
94134   Dali::Actor *result = 0 ;
94135
94136   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
94137   result = (Dali::Actor *)& ((arg1)->second);
94138   jresult = (void *)result;
94139   return jresult;
94140 }
94141
94142
94143 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Item(void * jarg1) {
94144   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
94145
94146   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
94147   {
94148     try {
94149       delete arg1;
94150     } catch (std::out_of_range& e) {
94151       {
94152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94153       };
94154     } catch (std::exception& e) {
94155       {
94156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94157       };
94158     } catch (Dali::DaliException e) {
94159       {
94160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94161       };
94162     } catch (...) {
94163       {
94164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94165       };
94166     }
94167   }
94168
94169 }
94170
94171
94172 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Clear(void * jarg1) {
94173   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94174
94175   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94176   {
94177     try {
94178       (arg1)->clear();
94179     } catch (std::out_of_range& e) {
94180       {
94181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94182       };
94183     } catch (std::exception& e) {
94184       {
94185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94186       };
94187     } catch (Dali::DaliException e) {
94188       {
94189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94190       };
94191     } catch (...) {
94192       {
94193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94194       };
94195     }
94196   }
94197
94198 }
94199
94200
94201 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Add(void * jarg1, void * jarg2) {
94202   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94203   std::pair< unsigned int,Dali::Actor > *arg2 = 0 ;
94204
94205   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94206   arg2 = (std::pair< unsigned int,Dali::Actor > *)jarg2;
94207   if (!arg2) {
94208     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
94209     return ;
94210   }
94211   {
94212     try {
94213       (arg1)->push_back((std::pair< unsigned int,Dali::Actor > const &)*arg2);
94214     } catch (std::out_of_range& e) {
94215       {
94216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94217       };
94218     } catch (std::exception& e) {
94219       {
94220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94221       };
94222     } catch (Dali::DaliException e) {
94223       {
94224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94225       };
94226     } catch (...) {
94227       {
94228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94229       };
94230     }
94231   }
94232
94233 }
94234
94235
94236 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_size(void * jarg1) {
94237   unsigned long jresult ;
94238   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94239   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
94240
94241   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94242   {
94243     try {
94244       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->size();
94245     } catch (std::out_of_range& e) {
94246       {
94247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94248       };
94249     } catch (std::exception& e) {
94250       {
94251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94252       };
94253     } catch (Dali::DaliException e) {
94254       {
94255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94256       };
94257     } catch (...) {
94258       {
94259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94260       };
94261     }
94262   }
94263
94264   jresult = (unsigned long)result;
94265   return jresult;
94266 }
94267
94268
94269 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_capacity(void * jarg1) {
94270   unsigned long jresult ;
94271   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94272   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
94273
94274   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94275   {
94276     try {
94277       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->capacity();
94278     } catch (std::out_of_range& e) {
94279       {
94280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94281       };
94282     } catch (std::exception& e) {
94283       {
94284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94285       };
94286     } catch (Dali::DaliException e) {
94287       {
94288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94289       };
94290     } catch (...) {
94291       {
94292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94293       };
94294     }
94295   }
94296
94297   jresult = (unsigned long)result;
94298   return jresult;
94299 }
94300
94301
94302 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_reserve(void * jarg1, unsigned long jarg2) {
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 arg2 ;
94305
94306   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94307   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > >::size_type)jarg2;
94308   {
94309     try {
94310       (arg1)->reserve(arg2);
94311     } catch (std::out_of_range& e) {
94312       {
94313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94314       };
94315     } catch (std::exception& e) {
94316       {
94317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94318       };
94319     } catch (Dali::DaliException e) {
94320       {
94321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94322       };
94323     } catch (...) {
94324       {
94325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94326       };
94327     }
94328   }
94329
94330 }
94331
94332
94333 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_0() {
94334   void * jresult ;
94335   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
94336
94337   {
94338     try {
94339       result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)new std::vector< std::pair< unsigned int,Dali::Actor > >();
94340     } catch (std::out_of_range& e) {
94341       {
94342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94343       };
94344     } catch (std::exception& e) {
94345       {
94346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94347       };
94348     } catch (Dali::DaliException e) {
94349       {
94350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94351       };
94352     } catch (...) {
94353       {
94354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94355       };
94356     }
94357   }
94358
94359   jresult = (void *)result;
94360   return jresult;
94361 }
94362
94363
94364 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_1(void * jarg1) {
94365   void * jresult ;
94366   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = 0 ;
94367   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
94368
94369   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94370   if (!arg1) {
94371     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
94372     return 0;
94373   }
94374   {
94375     try {
94376       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);
94377     } catch (std::out_of_range& e) {
94378       {
94379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94380       };
94381     } catch (std::exception& e) {
94382       {
94383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94384       };
94385     } catch (Dali::DaliException e) {
94386       {
94387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94388       };
94389     } catch (...) {
94390       {
94391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94392       };
94393     }
94394   }
94395
94396   jresult = (void *)result;
94397   return jresult;
94398 }
94399
94400
94401 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_2(int jarg1) {
94402   void * jresult ;
94403   int arg1 ;
94404   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
94405
94406   arg1 = (int)jarg1;
94407   {
94408     try {
94409       try {
94410         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);
94411       }
94412       catch(std::out_of_range &_e) {
94413         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94414         return 0;
94415       }
94416
94417     } catch (std::out_of_range& e) {
94418       {
94419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94420       };
94421     } catch (std::exception& e) {
94422       {
94423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94424       };
94425     } catch (Dali::DaliException e) {
94426       {
94427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94428       };
94429     } catch (...) {
94430       {
94431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94432       };
94433     }
94434   }
94435
94436   jresult = (void *)result;
94437   return jresult;
94438 }
94439
94440
94441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitemcopy(void * jarg1, int jarg2) {
94442   void * jresult ;
94443   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94444   int arg2 ;
94445   std::pair< unsigned int,Dali::Actor > result;
94446
94447   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94448   arg2 = (int)jarg2;
94449   {
94450     try {
94451       try {
94452         result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(arg1,arg2);
94453       }
94454       catch(std::out_of_range &_e) {
94455         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94456         return 0;
94457       }
94458
94459     } catch (std::out_of_range& e) {
94460       {
94461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94462       };
94463     } catch (std::exception& e) {
94464       {
94465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94466       };
94467     } catch (Dali::DaliException e) {
94468       {
94469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94470       };
94471     } catch (...) {
94472       {
94473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94474       };
94475     }
94476   }
94477
94478   jresult = new std::pair< unsigned int,Dali::Actor >((const std::pair< unsigned int,Dali::Actor > &)result);
94479   return jresult;
94480 }
94481
94482
94483 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitem(void * jarg1, int jarg2) {
94484   void * jresult ;
94485   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94486   int arg2 ;
94487   std::pair< unsigned int,Dali::Actor > *result = 0 ;
94488
94489   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94490   arg2 = (int)jarg2;
94491   {
94492     try {
94493       try {
94494         result = (std::pair< unsigned int,Dali::Actor > *) &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(arg1,arg2);
94495       }
94496       catch(std::out_of_range &_e) {
94497         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94498         return 0;
94499       }
94500
94501     } catch (std::out_of_range& e) {
94502       {
94503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94504       };
94505     } catch (std::exception& e) {
94506       {
94507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94508       };
94509     } catch (Dali::DaliException e) {
94510       {
94511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94512       };
94513     } catch (...) {
94514       {
94515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94516       };
94517     }
94518   }
94519
94520   jresult = (void *)result;
94521   return jresult;
94522 }
94523
94524
94525 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
94526   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94527   int arg2 ;
94528   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
94529
94530   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94531   arg2 = (int)jarg2;
94532   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
94533   if (!arg3) {
94534     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
94535     return ;
94536   }
94537   {
94538     try {
94539       try {
94540         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__setitem(arg1,arg2,(std::pair< unsigned int,Dali::Actor > const &)*arg3);
94541       }
94542       catch(std::out_of_range &_e) {
94543         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94544         return ;
94545       }
94546
94547     } catch (std::out_of_range& e) {
94548       {
94549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94550       };
94551     } catch (std::exception& e) {
94552       {
94553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94554       };
94555     } catch (Dali::DaliException e) {
94556       {
94557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94558       };
94559     } catch (...) {
94560       {
94561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94562       };
94563     }
94564   }
94565
94566 }
94567
94568
94569 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_AddRange(void * jarg1, void * jarg2) {
94570   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94571   std::vector< std::pair< unsigned int,Dali::Actor > > *arg2 = 0 ;
94572
94573   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94574   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg2;
94575   if (!arg2) {
94576     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
94577     return ;
94578   }
94579   {
94580     try {
94581       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);
94582     } catch (std::out_of_range& e) {
94583       {
94584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94585       };
94586     } catch (std::exception& e) {
94587       {
94588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94589       };
94590     } catch (Dali::DaliException e) {
94591       {
94592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94593       };
94594     } catch (...) {
94595       {
94596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94597       };
94598     }
94599   }
94600
94601 }
94602
94603
94604 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
94605   void * jresult ;
94606   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94607   int arg2 ;
94608   int arg3 ;
94609   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
94610
94611   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94612   arg2 = (int)jarg2;
94613   arg3 = (int)jarg3;
94614   {
94615     try {
94616       try {
94617         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);
94618       }
94619       catch(std::out_of_range &_e) {
94620         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94621         return 0;
94622       }
94623       catch(std::invalid_argument &_e) {
94624         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
94625         return 0;
94626       }
94627
94628     } catch (std::out_of_range& e) {
94629       {
94630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94631       };
94632     } catch (std::exception& e) {
94633       {
94634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94635       };
94636     } catch (Dali::DaliException e) {
94637       {
94638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94639       };
94640     } catch (...) {
94641       {
94642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94643       };
94644     }
94645   }
94646
94647   jresult = (void *)result;
94648   return jresult;
94649 }
94650
94651
94652 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
94653   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94654   int arg2 ;
94655   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
94656
94657   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94658   arg2 = (int)jarg2;
94659   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
94660   if (!arg3) {
94661     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
94662     return ;
94663   }
94664   {
94665     try {
94666       try {
94667         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);
94668       }
94669       catch(std::out_of_range &_e) {
94670         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94671         return ;
94672       }
94673
94674     } catch (std::out_of_range& e) {
94675       {
94676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94677       };
94678     } catch (std::exception& e) {
94679       {
94680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94681       };
94682     } catch (Dali::DaliException e) {
94683       {
94684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94685       };
94686     } catch (...) {
94687       {
94688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94689       };
94690     }
94691   }
94692
94693 }
94694
94695
94696 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
94697   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94698   int arg2 ;
94699   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
94700
94701   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94702   arg2 = (int)jarg2;
94703   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
94704   if (!arg3) {
94705     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
94706     return ;
94707   }
94708   {
94709     try {
94710       try {
94711         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);
94712       }
94713       catch(std::out_of_range &_e) {
94714         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94715         return ;
94716       }
94717
94718     } catch (std::out_of_range& e) {
94719       {
94720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94721       };
94722     } catch (std::exception& e) {
94723       {
94724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94725       };
94726     } catch (Dali::DaliException e) {
94727       {
94728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94729       };
94730     } catch (...) {
94731       {
94732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94733       };
94734     }
94735   }
94736
94737 }
94738
94739
94740 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveAt(void * jarg1, int jarg2) {
94741   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94742   int arg2 ;
94743
94744   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94745   arg2 = (int)jarg2;
94746   {
94747     try {
94748       try {
94749         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(arg1,arg2);
94750       }
94751       catch(std::out_of_range &_e) {
94752         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94753         return ;
94754       }
94755
94756     } catch (std::out_of_range& e) {
94757       {
94758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94759       };
94760     } catch (std::exception& e) {
94761       {
94762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94763       };
94764     } catch (Dali::DaliException e) {
94765       {
94766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94767       };
94768     } catch (...) {
94769       {
94770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94771       };
94772     }
94773   }
94774
94775 }
94776
94777
94778 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
94779   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94780   int arg2 ;
94781   int arg3 ;
94782
94783   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94784   arg2 = (int)jarg2;
94785   arg3 = (int)jarg3;
94786   {
94787     try {
94788       try {
94789         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(arg1,arg2,arg3);
94790       }
94791       catch(std::out_of_range &_e) {
94792         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94793         return ;
94794       }
94795       catch(std::invalid_argument &_e) {
94796         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
94797         return ;
94798       }
94799
94800     } catch (std::out_of_range& e) {
94801       {
94802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94803       };
94804     } catch (std::exception& e) {
94805       {
94806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94807       };
94808     } catch (Dali::DaliException e) {
94809       {
94810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94811       };
94812     } catch (...) {
94813       {
94814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94815       };
94816     }
94817   }
94818
94819 }
94820
94821
94822 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_Repeat(void * jarg1, int jarg2) {
94823   void * jresult ;
94824   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
94825   int arg2 ;
94826   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
94827
94828   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
94829   if (!arg1) {
94830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
94831     return 0;
94832   }
94833   arg2 = (int)jarg2;
94834   {
94835     try {
94836       try {
94837         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);
94838       }
94839       catch(std::out_of_range &_e) {
94840         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94841         return 0;
94842       }
94843
94844     } catch (std::out_of_range& e) {
94845       {
94846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94847       };
94848     } catch (std::exception& e) {
94849       {
94850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94851       };
94852     } catch (Dali::DaliException e) {
94853       {
94854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94855       };
94856     } catch (...) {
94857       {
94858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94859       };
94860     }
94861   }
94862
94863   jresult = (void *)result;
94864   return jresult;
94865 }
94866
94867
94868 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_0(void * jarg1) {
94869   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94870
94871   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94872   {
94873     try {
94874       std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(arg1);
94875     } catch (std::out_of_range& e) {
94876       {
94877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94878       };
94879     } catch (std::exception& e) {
94880       {
94881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94882       };
94883     } catch (Dali::DaliException e) {
94884       {
94885         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94886       };
94887     } catch (...) {
94888       {
94889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94890       };
94891     }
94892   }
94893
94894 }
94895
94896
94897 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
94898   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94899   int arg2 ;
94900   int arg3 ;
94901
94902   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94903   arg2 = (int)jarg2;
94904   arg3 = (int)jarg3;
94905   {
94906     try {
94907       try {
94908         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
94909       }
94910       catch(std::out_of_range &_e) {
94911         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94912         return ;
94913       }
94914       catch(std::invalid_argument &_e) {
94915         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
94916         return ;
94917       }
94918
94919     } catch (std::out_of_range& e) {
94920       {
94921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94922       };
94923     } catch (std::exception& e) {
94924       {
94925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94926       };
94927     } catch (Dali::DaliException e) {
94928       {
94929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94930       };
94931     } catch (...) {
94932       {
94933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94934       };
94935     }
94936   }
94937
94938 }
94939
94940
94941 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
94942   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94943   int arg2 ;
94944   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
94945
94946   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94947   arg2 = (int)jarg2;
94948   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
94949   if (!arg3) {
94950     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
94951     return ;
94952   }
94953   {
94954     try {
94955       try {
94956         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);
94957       }
94958       catch(std::out_of_range &_e) {
94959         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94960         return ;
94961       }
94962
94963     } catch (std::out_of_range& e) {
94964       {
94965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94966       };
94967     } catch (std::exception& e) {
94968       {
94969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94970       };
94971     } catch (Dali::DaliException e) {
94972       {
94973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94974       };
94975     } catch (...) {
94976       {
94977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94978       };
94979     }
94980   }
94981
94982 }
94983
94984
94985 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemContainer(void * jarg1) {
94986   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94987
94988   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94989   {
94990     try {
94991       delete arg1;
94992     } catch (std::out_of_range& e) {
94993       {
94994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94995       };
94996     } catch (std::exception& e) {
94997       {
94998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94999       };
95000     } catch (Dali::DaliException e) {
95001       {
95002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95003       };
95004     } catch (...) {
95005       {
95006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95007       };
95008     }
95009   }
95010
95011 }
95012
95013
95014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Clear(void * jarg1) {
95015   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95016
95017   arg1 = (std::vector< Dali::Actor > *)jarg1;
95018   {
95019     try {
95020       (arg1)->clear();
95021     } catch (std::out_of_range& e) {
95022       {
95023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95024       };
95025     } catch (std::exception& e) {
95026       {
95027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95028       };
95029     } catch (Dali::DaliException e) {
95030       {
95031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95032       };
95033     } catch (...) {
95034       {
95035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95036       };
95037     }
95038   }
95039
95040 }
95041
95042
95043 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Add(void * jarg1, void * jarg2) {
95044   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95045   Dali::Actor *arg2 = 0 ;
95046
95047   arg1 = (std::vector< Dali::Actor > *)jarg1;
95048   arg2 = (Dali::Actor *)jarg2;
95049   if (!arg2) {
95050     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
95051     return ;
95052   }
95053   {
95054     try {
95055       (arg1)->push_back((Dali::Actor const &)*arg2);
95056     } catch (std::out_of_range& e) {
95057       {
95058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95059       };
95060     } catch (std::exception& e) {
95061       {
95062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95063       };
95064     } catch (Dali::DaliException e) {
95065       {
95066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95067       };
95068     } catch (...) {
95069       {
95070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95071       };
95072     }
95073   }
95074
95075 }
95076
95077
95078 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_size(void * jarg1) {
95079   unsigned long jresult ;
95080   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95081   std::vector< Dali::Actor >::size_type result;
95082
95083   arg1 = (std::vector< Dali::Actor > *)jarg1;
95084   {
95085     try {
95086       result = ((std::vector< Dali::Actor > const *)arg1)->size();
95087     } catch (std::out_of_range& e) {
95088       {
95089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95090       };
95091     } catch (std::exception& e) {
95092       {
95093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95094       };
95095     } catch (Dali::DaliException e) {
95096       {
95097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95098       };
95099     } catch (...) {
95100       {
95101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95102       };
95103     }
95104   }
95105
95106   jresult = (unsigned long)result;
95107   return jresult;
95108 }
95109
95110
95111 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_capacity(void * jarg1) {
95112   unsigned long jresult ;
95113   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95114   std::vector< Dali::Actor >::size_type result;
95115
95116   arg1 = (std::vector< Dali::Actor > *)jarg1;
95117   {
95118     try {
95119       result = ((std::vector< Dali::Actor > const *)arg1)->capacity();
95120     } catch (std::out_of_range& e) {
95121       {
95122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95123       };
95124     } catch (std::exception& e) {
95125       {
95126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95127       };
95128     } catch (Dali::DaliException e) {
95129       {
95130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95131       };
95132     } catch (...) {
95133       {
95134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95135       };
95136     }
95137   }
95138
95139   jresult = (unsigned long)result;
95140   return jresult;
95141 }
95142
95143
95144 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_reserve(void * jarg1, unsigned long jarg2) {
95145   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95146   std::vector< Dali::Actor >::size_type arg2 ;
95147
95148   arg1 = (std::vector< Dali::Actor > *)jarg1;
95149   arg2 = (std::vector< Dali::Actor >::size_type)jarg2;
95150   {
95151     try {
95152       (arg1)->reserve(arg2);
95153     } catch (std::out_of_range& e) {
95154       {
95155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95156       };
95157     } catch (std::exception& e) {
95158       {
95159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95160       };
95161     } catch (Dali::DaliException e) {
95162       {
95163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95164       };
95165     } catch (...) {
95166       {
95167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95168       };
95169     }
95170   }
95171
95172 }
95173
95174
95175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_0() {
95176   void * jresult ;
95177   std::vector< Dali::Actor > *result = 0 ;
95178
95179   {
95180     try {
95181       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >();
95182     } catch (std::out_of_range& e) {
95183       {
95184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95185       };
95186     } catch (std::exception& e) {
95187       {
95188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95189       };
95190     } catch (Dali::DaliException e) {
95191       {
95192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95193       };
95194     } catch (...) {
95195       {
95196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95197       };
95198     }
95199   }
95200
95201   jresult = (void *)result;
95202   return jresult;
95203 }
95204
95205
95206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_1(void * jarg1) {
95207   void * jresult ;
95208   std::vector< Dali::Actor > *arg1 = 0 ;
95209   std::vector< Dali::Actor > *result = 0 ;
95210
95211   arg1 = (std::vector< Dali::Actor > *)jarg1;
95212   if (!arg1) {
95213     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
95214     return 0;
95215   }
95216   {
95217     try {
95218       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >((std::vector< Dali::Actor > const &)*arg1);
95219     } catch (std::out_of_range& e) {
95220       {
95221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95222       };
95223     } catch (std::exception& e) {
95224       {
95225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95226       };
95227     } catch (Dali::DaliException e) {
95228       {
95229         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95230       };
95231     } catch (...) {
95232       {
95233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95234       };
95235     }
95236   }
95237
95238   jresult = (void *)result;
95239   return jresult;
95240 }
95241
95242
95243 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_2(int jarg1) {
95244   void * jresult ;
95245   int arg1 ;
95246   std::vector< Dali::Actor > *result = 0 ;
95247
95248   arg1 = (int)jarg1;
95249   {
95250     try {
95251       try {
95252         result = (std::vector< Dali::Actor > *)new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(arg1);
95253       }
95254       catch(std::out_of_range &_e) {
95255         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95256         return 0;
95257       }
95258
95259     } catch (std::out_of_range& e) {
95260       {
95261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95262       };
95263     } catch (std::exception& e) {
95264       {
95265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95266       };
95267     } catch (Dali::DaliException e) {
95268       {
95269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95270       };
95271     } catch (...) {
95272       {
95273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95274       };
95275     }
95276   }
95277
95278   jresult = (void *)result;
95279   return jresult;
95280 }
95281
95282
95283 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitemcopy(void * jarg1, int jarg2) {
95284   void * jresult ;
95285   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95286   int arg2 ;
95287   Dali::Actor result;
95288
95289   arg1 = (std::vector< Dali::Actor > *)jarg1;
95290   arg2 = (int)jarg2;
95291   {
95292     try {
95293       try {
95294         result = std_vector_Sl_Dali_Actor_Sg__getitemcopy(arg1,arg2);
95295       }
95296       catch(std::out_of_range &_e) {
95297         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95298         return 0;
95299       }
95300
95301     } catch (std::out_of_range& e) {
95302       {
95303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95304       };
95305     } catch (std::exception& e) {
95306       {
95307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95308       };
95309     } catch (Dali::DaliException e) {
95310       {
95311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95312       };
95313     } catch (...) {
95314       {
95315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95316       };
95317     }
95318   }
95319
95320   jresult = new Dali::Actor((const Dali::Actor &)result);
95321   return jresult;
95322 }
95323
95324
95325 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitem(void * jarg1, int jarg2) {
95326   void * jresult ;
95327   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95328   int arg2 ;
95329   Dali::Actor *result = 0 ;
95330
95331   arg1 = (std::vector< Dali::Actor > *)jarg1;
95332   arg2 = (int)jarg2;
95333   {
95334     try {
95335       try {
95336         result = (Dali::Actor *) &std_vector_Sl_Dali_Actor_Sg__getitem(arg1,arg2);
95337       }
95338       catch(std::out_of_range &_e) {
95339         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95340         return 0;
95341       }
95342
95343     } catch (std::out_of_range& e) {
95344       {
95345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95346       };
95347     } catch (std::exception& e) {
95348       {
95349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95350       };
95351     } catch (Dali::DaliException e) {
95352       {
95353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95354       };
95355     } catch (...) {
95356       {
95357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95358       };
95359     }
95360   }
95361
95362   jresult = (void *)result;
95363   return jresult;
95364 }
95365
95366
95367 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
95368   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95369   int arg2 ;
95370   Dali::Actor *arg3 = 0 ;
95371
95372   arg1 = (std::vector< Dali::Actor > *)jarg1;
95373   arg2 = (int)jarg2;
95374   arg3 = (Dali::Actor *)jarg3;
95375   if (!arg3) {
95376     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
95377     return ;
95378   }
95379   {
95380     try {
95381       try {
95382         std_vector_Sl_Dali_Actor_Sg__setitem(arg1,arg2,(Dali::Actor const &)*arg3);
95383       }
95384       catch(std::out_of_range &_e) {
95385         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95386         return ;
95387       }
95388
95389     } catch (std::out_of_range& e) {
95390       {
95391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95392       };
95393     } catch (std::exception& e) {
95394       {
95395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95396       };
95397     } catch (Dali::DaliException e) {
95398       {
95399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95400       };
95401     } catch (...) {
95402       {
95403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95404       };
95405     }
95406   }
95407
95408 }
95409
95410
95411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_AddRange(void * jarg1, void * jarg2) {
95412   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95413   std::vector< Dali::Actor > *arg2 = 0 ;
95414
95415   arg1 = (std::vector< Dali::Actor > *)jarg1;
95416   arg2 = (std::vector< Dali::Actor > *)jarg2;
95417   if (!arg2) {
95418     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
95419     return ;
95420   }
95421   {
95422     try {
95423       std_vector_Sl_Dali_Actor_Sg__AddRange(arg1,(std::vector< Dali::Actor > const &)*arg2);
95424     } catch (std::out_of_range& e) {
95425       {
95426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95427       };
95428     } catch (std::exception& e) {
95429       {
95430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95431       };
95432     } catch (Dali::DaliException e) {
95433       {
95434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95435       };
95436     } catch (...) {
95437       {
95438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95439       };
95440     }
95441   }
95442
95443 }
95444
95445
95446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
95447   void * jresult ;
95448   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95449   int arg2 ;
95450   int arg3 ;
95451   std::vector< Dali::Actor > *result = 0 ;
95452
95453   arg1 = (std::vector< Dali::Actor > *)jarg1;
95454   arg2 = (int)jarg2;
95455   arg3 = (int)jarg3;
95456   {
95457     try {
95458       try {
95459         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__GetRange(arg1,arg2,arg3);
95460       }
95461       catch(std::out_of_range &_e) {
95462         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95463         return 0;
95464       }
95465       catch(std::invalid_argument &_e) {
95466         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
95467         return 0;
95468       }
95469
95470     } catch (std::out_of_range& e) {
95471       {
95472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95473       };
95474     } catch (std::exception& e) {
95475       {
95476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95477       };
95478     } catch (Dali::DaliException e) {
95479       {
95480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95481       };
95482     } catch (...) {
95483       {
95484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95485       };
95486     }
95487   }
95488
95489   jresult = (void *)result;
95490   return jresult;
95491 }
95492
95493
95494 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
95495   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95496   int arg2 ;
95497   Dali::Actor *arg3 = 0 ;
95498
95499   arg1 = (std::vector< Dali::Actor > *)jarg1;
95500   arg2 = (int)jarg2;
95501   arg3 = (Dali::Actor *)jarg3;
95502   if (!arg3) {
95503     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
95504     return ;
95505   }
95506   {
95507     try {
95508       try {
95509         std_vector_Sl_Dali_Actor_Sg__Insert(arg1,arg2,(Dali::Actor const &)*arg3);
95510       }
95511       catch(std::out_of_range &_e) {
95512         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95513         return ;
95514       }
95515
95516     } catch (std::out_of_range& e) {
95517       {
95518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95519       };
95520     } catch (std::exception& e) {
95521       {
95522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95523       };
95524     } catch (Dali::DaliException e) {
95525       {
95526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95527       };
95528     } catch (...) {
95529       {
95530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95531       };
95532     }
95533   }
95534
95535 }
95536
95537
95538 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
95539   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95540   int arg2 ;
95541   std::vector< Dali::Actor > *arg3 = 0 ;
95542
95543   arg1 = (std::vector< Dali::Actor > *)jarg1;
95544   arg2 = (int)jarg2;
95545   arg3 = (std::vector< Dali::Actor > *)jarg3;
95546   if (!arg3) {
95547     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
95548     return ;
95549   }
95550   {
95551     try {
95552       try {
95553         std_vector_Sl_Dali_Actor_Sg__InsertRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
95554       }
95555       catch(std::out_of_range &_e) {
95556         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95557         return ;
95558       }
95559
95560     } catch (std::out_of_range& e) {
95561       {
95562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95563       };
95564     } catch (std::exception& e) {
95565       {
95566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95567       };
95568     } catch (Dali::DaliException e) {
95569       {
95570         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95571       };
95572     } catch (...) {
95573       {
95574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95575       };
95576     }
95577   }
95578
95579 }
95580
95581
95582 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveAt(void * jarg1, int jarg2) {
95583   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95584   int arg2 ;
95585
95586   arg1 = (std::vector< Dali::Actor > *)jarg1;
95587   arg2 = (int)jarg2;
95588   {
95589     try {
95590       try {
95591         std_vector_Sl_Dali_Actor_Sg__RemoveAt(arg1,arg2);
95592       }
95593       catch(std::out_of_range &_e) {
95594         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95595         return ;
95596       }
95597
95598     } catch (std::out_of_range& e) {
95599       {
95600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95601       };
95602     } catch (std::exception& e) {
95603       {
95604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95605       };
95606     } catch (Dali::DaliException e) {
95607       {
95608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95609       };
95610     } catch (...) {
95611       {
95612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95613       };
95614     }
95615   }
95616
95617 }
95618
95619
95620 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
95621   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95622   int arg2 ;
95623   int arg3 ;
95624
95625   arg1 = (std::vector< Dali::Actor > *)jarg1;
95626   arg2 = (int)jarg2;
95627   arg3 = (int)jarg3;
95628   {
95629     try {
95630       try {
95631         std_vector_Sl_Dali_Actor_Sg__RemoveRange(arg1,arg2,arg3);
95632       }
95633       catch(std::out_of_range &_e) {
95634         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95635         return ;
95636       }
95637       catch(std::invalid_argument &_e) {
95638         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
95639         return ;
95640       }
95641
95642     } catch (std::out_of_range& e) {
95643       {
95644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95645       };
95646     } catch (std::exception& e) {
95647       {
95648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95649       };
95650     } catch (Dali::DaliException e) {
95651       {
95652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95653       };
95654     } catch (...) {
95655       {
95656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95657       };
95658     }
95659   }
95660
95661 }
95662
95663
95664 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_Repeat(void * jarg1, int jarg2) {
95665   void * jresult ;
95666   Dali::Actor *arg1 = 0 ;
95667   int arg2 ;
95668   std::vector< Dali::Actor > *result = 0 ;
95669
95670   arg1 = (Dali::Actor *)jarg1;
95671   if (!arg1) {
95672     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
95673     return 0;
95674   }
95675   arg2 = (int)jarg2;
95676   {
95677     try {
95678       try {
95679         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__Repeat((Dali::Actor const &)*arg1,arg2);
95680       }
95681       catch(std::out_of_range &_e) {
95682         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95683         return 0;
95684       }
95685
95686     } catch (std::out_of_range& e) {
95687       {
95688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95689       };
95690     } catch (std::exception& e) {
95691       {
95692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95693       };
95694     } catch (Dali::DaliException e) {
95695       {
95696         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95697       };
95698     } catch (...) {
95699       {
95700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95701       };
95702     }
95703   }
95704
95705   jresult = (void *)result;
95706   return jresult;
95707 }
95708
95709
95710 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_0(void * jarg1) {
95711   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95712
95713   arg1 = (std::vector< Dali::Actor > *)jarg1;
95714   {
95715     try {
95716       std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(arg1);
95717     } catch (std::out_of_range& e) {
95718       {
95719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95720       };
95721     } catch (std::exception& e) {
95722       {
95723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95724       };
95725     } catch (Dali::DaliException e) {
95726       {
95727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95728       };
95729     } catch (...) {
95730       {
95731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95732       };
95733     }
95734   }
95735
95736 }
95737
95738
95739 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
95740   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95741   int arg2 ;
95742   int arg3 ;
95743
95744   arg1 = (std::vector< Dali::Actor > *)jarg1;
95745   arg2 = (int)jarg2;
95746   arg3 = (int)jarg3;
95747   {
95748     try {
95749       try {
95750         std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
95751       }
95752       catch(std::out_of_range &_e) {
95753         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95754         return ;
95755       }
95756       catch(std::invalid_argument &_e) {
95757         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
95758         return ;
95759       }
95760
95761     } catch (std::out_of_range& e) {
95762       {
95763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95764       };
95765     } catch (std::exception& e) {
95766       {
95767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95768       };
95769     } catch (Dali::DaliException e) {
95770       {
95771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95772       };
95773     } catch (...) {
95774       {
95775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95776       };
95777     }
95778   }
95779
95780 }
95781
95782
95783 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
95784   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95785   int arg2 ;
95786   std::vector< Dali::Actor > *arg3 = 0 ;
95787
95788   arg1 = (std::vector< Dali::Actor > *)jarg1;
95789   arg2 = (int)jarg2;
95790   arg3 = (std::vector< Dali::Actor > *)jarg3;
95791   if (!arg3) {
95792     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
95793     return ;
95794   }
95795   {
95796     try {
95797       try {
95798         std_vector_Sl_Dali_Actor_Sg__SetRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
95799       }
95800       catch(std::out_of_range &_e) {
95801         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95802         return ;
95803       }
95804
95805     } catch (std::out_of_range& e) {
95806       {
95807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95808       };
95809     } catch (std::exception& e) {
95810       {
95811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95812       };
95813     } catch (Dali::DaliException e) {
95814       {
95815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95816       };
95817     } catch (...) {
95818       {
95819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95820       };
95821     }
95822   }
95823
95824 }
95825
95826
95827 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorContainer(void * jarg1) {
95828   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95829
95830   arg1 = (std::vector< Dali::Actor > *)jarg1;
95831   {
95832     try {
95833       delete arg1;
95834     } catch (std::out_of_range& e) {
95835       {
95836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95837       };
95838     } catch (std::exception& e) {
95839       {
95840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95841       };
95842     } catch (Dali::DaliException e) {
95843       {
95844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95845       };
95846     } catch (...) {
95847       {
95848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95849       };
95850     }
95851   }
95852
95853 }
95854
95855
95856 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Empty(void * jarg1) {
95857   unsigned int jresult ;
95858   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95859   bool result;
95860
95861   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95862   {
95863     try {
95864       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
95865     } catch (std::out_of_range& e) {
95866       {
95867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95868       };
95869     } catch (std::exception& e) {
95870       {
95871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95872       };
95873     } catch (Dali::DaliException e) {
95874       {
95875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95876       };
95877     } catch (...) {
95878       {
95879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95880       };
95881     }
95882   }
95883
95884   jresult = result;
95885   return jresult;
95886 }
95887
95888
95889 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_GetConnectionCount(void * jarg1) {
95890   unsigned long jresult ;
95891   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95892   std::size_t result;
95893
95894   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95895   {
95896     try {
95897       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
95898     } catch (std::out_of_range& e) {
95899       {
95900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95901       };
95902     } catch (std::exception& e) {
95903       {
95904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95905       };
95906     } catch (Dali::DaliException e) {
95907       {
95908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95909       };
95910     } catch (...) {
95911       {
95912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95913       };
95914     }
95915   }
95916
95917   jresult = (unsigned long)result;
95918   return jresult;
95919 }
95920
95921
95922 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Connect(void * jarg1, void * jarg2) {
95923   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95924   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
95925
95926   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95927   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
95928   {
95929     try {
95930       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(arg1,arg2);
95931     } catch (std::out_of_range& e) {
95932       {
95933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95934       };
95935     } catch (std::exception& e) {
95936       {
95937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95938       };
95939     } catch (Dali::DaliException e) {
95940       {
95941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95942       };
95943     } catch (...) {
95944       {
95945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95946       };
95947     }
95948   }
95949
95950 }
95951
95952
95953 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Disconnect(void * jarg1, void * jarg2) {
95954   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95955   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
95956
95957   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95958   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
95959   {
95960     try {
95961       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(arg1,arg2);
95962     } catch (std::out_of_range& e) {
95963       {
95964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95965       };
95966     } catch (std::exception& e) {
95967       {
95968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95969       };
95970     } catch (Dali::DaliException e) {
95971       {
95972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95973       };
95974     } catch (...) {
95975       {
95976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95977       };
95978     }
95979   }
95980
95981 }
95982
95983
95984 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Emit(void * jarg1, void * jarg2) {
95985   unsigned int jresult ;
95986   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95987   Dali::Toolkit::AccessibilityManager *arg2 = 0 ;
95988   bool result;
95989
95990   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95991   arg2 = (Dali::Toolkit::AccessibilityManager *)jarg2;
95992   if (!arg2) {
95993     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AccessibilityManager & type is null", 0);
95994     return 0;
95995   }
95996   {
95997     try {
95998       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(arg1,*arg2);
95999     } catch (std::out_of_range& e) {
96000       {
96001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96002       };
96003     } catch (std::exception& e) {
96004       {
96005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96006       };
96007     } catch (Dali::DaliException e) {
96008       {
96009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96010       };
96011     } catch (...) {
96012       {
96013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96014       };
96015     }
96016   }
96017
96018   jresult = result;
96019   return jresult;
96020 }
96021
96022
96023 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityActionSignal() {
96024   void * jresult ;
96025   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *result = 0 ;
96026
96027   {
96028     try {
96029       result = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)new Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) >();
96030     } catch (std::out_of_range& e) {
96031       {
96032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96033       };
96034     } catch (std::exception& e) {
96035       {
96036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96037       };
96038     } catch (Dali::DaliException e) {
96039       {
96040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96041       };
96042     } catch (...) {
96043       {
96044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96045       };
96046     }
96047   }
96048
96049   jresult = (void *)result;
96050   return jresult;
96051 }
96052
96053
96054 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityActionSignal(void * jarg1) {
96055   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
96056
96057   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
96058   {
96059     try {
96060       delete arg1;
96061     } catch (std::out_of_range& e) {
96062       {
96063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96064       };
96065     } catch (std::exception& e) {
96066       {
96067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96068       };
96069     } catch (Dali::DaliException e) {
96070       {
96071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96072       };
96073     } catch (...) {
96074       {
96075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96076       };
96077     }
96078   }
96079
96080 }
96081
96082
96083 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Empty(void * jarg1) {
96084   unsigned int jresult ;
96085   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
96086   bool result;
96087
96088   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
96089   {
96090     try {
96091       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);
96092     } catch (std::out_of_range& e) {
96093       {
96094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96095       };
96096     } catch (std::exception& e) {
96097       {
96098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96099       };
96100     } catch (Dali::DaliException e) {
96101       {
96102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96103       };
96104     } catch (...) {
96105       {
96106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96107       };
96108     }
96109   }
96110
96111   jresult = result;
96112   return jresult;
96113 }
96114
96115
96116 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_GetConnectionCount(void * jarg1) {
96117   unsigned long jresult ;
96118   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
96119   std::size_t result;
96120
96121   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
96122   {
96123     try {
96124       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);
96125     } catch (std::out_of_range& e) {
96126       {
96127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96128       };
96129     } catch (std::exception& e) {
96130       {
96131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96132       };
96133     } catch (Dali::DaliException e) {
96134       {
96135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96136       };
96137     } catch (...) {
96138       {
96139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96140       };
96141     }
96142   }
96143
96144   jresult = (unsigned long)result;
96145   return jresult;
96146 }
96147
96148
96149 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Connect(void * jarg1, void * jarg2) {
96150   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
96151   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
96152
96153   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
96154   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
96155   {
96156     try {
96157       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(arg1,arg2);
96158     } catch (std::out_of_range& e) {
96159       {
96160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96161       };
96162     } catch (std::exception& e) {
96163       {
96164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96165       };
96166     } catch (Dali::DaliException e) {
96167       {
96168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96169       };
96170     } catch (...) {
96171       {
96172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96173       };
96174     }
96175   }
96176
96177 }
96178
96179
96180 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Disconnect(void * jarg1, void * jarg2) {
96181   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
96182   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
96183
96184   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
96185   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
96186   {
96187     try {
96188       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(arg1,arg2);
96189     } catch (std::out_of_range& e) {
96190       {
96191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96192       };
96193     } catch (std::exception& e) {
96194       {
96195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96196       };
96197     } catch (Dali::DaliException e) {
96198       {
96199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96200       };
96201     } catch (...) {
96202       {
96203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96204       };
96205     }
96206   }
96207
96208 }
96209
96210
96211 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
96212   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
96213   Dali::Actor arg2 ;
96214   Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg3 ;
96215   Dali::Actor *argp2 ;
96216
96217   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
96218   argp2 = (Dali::Actor *)jarg2;
96219   if (!argp2) {
96220     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
96221     return ;
96222   }
96223   arg2 = *argp2;
96224   arg3 = (Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)jarg3;
96225   {
96226     try {
96227       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(arg1,arg2,arg3);
96228     } catch (std::out_of_range& e) {
96229       {
96230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96231       };
96232     } catch (std::exception& e) {
96233       {
96234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96235       };
96236     } catch (Dali::DaliException e) {
96237       {
96238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96239       };
96240     } catch (...) {
96241       {
96242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96243       };
96244     }
96245   }
96246
96247 }
96248
96249
96250 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityFocusOvershotSignal() {
96251   void * jresult ;
96252   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *result = 0 ;
96253
96254   {
96255     try {
96256       result = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)new Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) >();
96257     } catch (std::out_of_range& e) {
96258       {
96259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96260       };
96261     } catch (std::exception& e) {
96262       {
96263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96264       };
96265     } catch (Dali::DaliException e) {
96266       {
96267         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96268       };
96269     } catch (...) {
96270       {
96271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96272       };
96273     }
96274   }
96275
96276   jresult = (void *)result;
96277   return jresult;
96278 }
96279
96280
96281 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityFocusOvershotSignal(void * jarg1) {
96282   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
96283
96284   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
96285   {
96286     try {
96287       delete arg1;
96288     } catch (std::out_of_range& e) {
96289       {
96290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96291       };
96292     } catch (std::exception& e) {
96293       {
96294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96295       };
96296     } catch (Dali::DaliException e) {
96297       {
96298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96299       };
96300     } catch (...) {
96301       {
96302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96303       };
96304     }
96305   }
96306
96307 }
96308
96309
96310 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Empty(void * jarg1) {
96311   unsigned int jresult ;
96312   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
96313   bool result;
96314
96315   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
96316   {
96317     try {
96318       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
96319     } catch (std::out_of_range& e) {
96320       {
96321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96322       };
96323     } catch (std::exception& e) {
96324       {
96325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96326       };
96327     } catch (Dali::DaliException e) {
96328       {
96329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96330       };
96331     } catch (...) {
96332       {
96333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96334       };
96335     }
96336   }
96337
96338   jresult = result;
96339   return jresult;
96340 }
96341
96342
96343 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusChangedSignal_GetConnectionCount(void * jarg1) {
96344   unsigned long jresult ;
96345   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
96346   std::size_t result;
96347
96348   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
96349   {
96350     try {
96351       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
96352     } catch (std::out_of_range& e) {
96353       {
96354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96355       };
96356     } catch (std::exception& e) {
96357       {
96358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96359       };
96360     } catch (Dali::DaliException e) {
96361       {
96362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96363       };
96364     } catch (...) {
96365       {
96366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96367       };
96368     }
96369   }
96370
96371   jresult = (unsigned long)result;
96372   return jresult;
96373 }
96374
96375
96376 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Connect(void * jarg1, void * jarg2) {
96377   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
96378   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
96379
96380   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
96381   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
96382   {
96383     try {
96384       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(arg1,arg2);
96385     } catch (std::out_of_range& e) {
96386       {
96387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96388       };
96389     } catch (std::exception& e) {
96390       {
96391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96392       };
96393     } catch (Dali::DaliException e) {
96394       {
96395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96396       };
96397     } catch (...) {
96398       {
96399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96400       };
96401     }
96402   }
96403
96404 }
96405
96406
96407 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Disconnect(void * jarg1, void * jarg2) {
96408   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
96409   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
96410
96411   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
96412   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
96413   {
96414     try {
96415       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
96416     } catch (std::out_of_range& e) {
96417       {
96418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96419       };
96420     } catch (std::exception& e) {
96421       {
96422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96423       };
96424     } catch (Dali::DaliException e) {
96425       {
96426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96427       };
96428     } catch (...) {
96429       {
96430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96431       };
96432     }
96433   }
96434
96435 }
96436
96437
96438 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
96439   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
96440   Dali::Actor arg2 ;
96441   Dali::Actor arg3 ;
96442   Dali::Actor *argp2 ;
96443   Dali::Actor *argp3 ;
96444
96445   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
96446   argp2 = (Dali::Actor *)jarg2;
96447   if (!argp2) {
96448     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
96449     return ;
96450   }
96451   arg2 = *argp2;
96452   argp3 = (Dali::Actor *)jarg3;
96453   if (!argp3) {
96454     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
96455     return ;
96456   }
96457   arg3 = *argp3;
96458   {
96459     try {
96460       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(arg1,arg2,arg3);
96461     } catch (std::out_of_range& e) {
96462       {
96463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96464       };
96465     } catch (std::exception& e) {
96466       {
96467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96468       };
96469     } catch (Dali::DaliException e) {
96470       {
96471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96472       };
96473     } catch (...) {
96474       {
96475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96476       };
96477     }
96478   }
96479
96480 }
96481
96482
96483 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusChangedSignal() {
96484   void * jresult ;
96485   Dali::Signal< void (Dali::Actor,Dali::Actor) > *result = 0 ;
96486
96487   {
96488     try {
96489       result = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)new Dali::Signal< void (Dali::Actor,Dali::Actor) >();
96490     } catch (std::out_of_range& e) {
96491       {
96492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96493       };
96494     } catch (std::exception& e) {
96495       {
96496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96497       };
96498     } catch (Dali::DaliException e) {
96499       {
96500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96501       };
96502     } catch (...) {
96503       {
96504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96505       };
96506     }
96507   }
96508
96509   jresult = (void *)result;
96510   return jresult;
96511 }
96512
96513
96514 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusChangedSignal(void * jarg1) {
96515   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
96516
96517   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
96518   {
96519     try {
96520       delete arg1;
96521     } catch (std::out_of_range& e) {
96522       {
96523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96524       };
96525     } catch (std::exception& e) {
96526       {
96527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96528       };
96529     } catch (Dali::DaliException e) {
96530       {
96531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96532       };
96533     } catch (...) {
96534       {
96535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96536       };
96537     }
96538   }
96539
96540 }
96541
96542
96543 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Empty(void * jarg1) {
96544   unsigned int jresult ;
96545   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96546   bool result;
96547
96548   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96549   {
96550     try {
96551       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
96552     } catch (std::out_of_range& e) {
96553       {
96554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96555       };
96556     } catch (std::exception& e) {
96557       {
96558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96559       };
96560     } catch (Dali::DaliException e) {
96561       {
96562         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96563       };
96564     } catch (...) {
96565       {
96566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96567       };
96568     }
96569   }
96570
96571   jresult = result;
96572   return jresult;
96573 }
96574
96575
96576 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_GetConnectionCount(void * jarg1) {
96577   unsigned long jresult ;
96578   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96579   std::size_t result;
96580
96581   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96582   {
96583     try {
96584       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
96585     } catch (std::out_of_range& e) {
96586       {
96587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96588       };
96589     } catch (std::exception& e) {
96590       {
96591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96592       };
96593     } catch (Dali::DaliException e) {
96594       {
96595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96596       };
96597     } catch (...) {
96598       {
96599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96600       };
96601     }
96602   }
96603
96604   jresult = (unsigned long)result;
96605   return jresult;
96606 }
96607
96608
96609 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Connect(void * jarg1, void * jarg2) {
96610   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96611   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
96612
96613   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96614   arg2 = (void (*)(Dali::Actor,bool))jarg2;
96615   {
96616     try {
96617       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(arg1,arg2);
96618     } catch (std::out_of_range& e) {
96619       {
96620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96621       };
96622     } catch (std::exception& e) {
96623       {
96624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96625       };
96626     } catch (Dali::DaliException e) {
96627       {
96628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96629       };
96630     } catch (...) {
96631       {
96632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96633       };
96634     }
96635   }
96636
96637 }
96638
96639
96640 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Disconnect(void * jarg1, void * jarg2) {
96641   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96642   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
96643
96644   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96645   arg2 = (void (*)(Dali::Actor,bool))jarg2;
96646   {
96647     try {
96648       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
96649     } catch (std::out_of_range& e) {
96650       {
96651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96652       };
96653     } catch (std::exception& e) {
96654       {
96655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96656       };
96657     } catch (Dali::DaliException e) {
96658       {
96659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96660       };
96661     } catch (...) {
96662       {
96663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96664       };
96665     }
96666   }
96667
96668 }
96669
96670
96671 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3) {
96672   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96673   Dali::Actor arg2 ;
96674   bool arg3 ;
96675   Dali::Actor *argp2 ;
96676
96677   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96678   argp2 = (Dali::Actor *)jarg2;
96679   if (!argp2) {
96680     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
96681     return ;
96682   }
96683   arg2 = *argp2;
96684   arg3 = jarg3 ? true : false;
96685   {
96686     try {
96687       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3);
96688     } catch (std::out_of_range& e) {
96689       {
96690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96691       };
96692     } catch (std::exception& e) {
96693       {
96694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96695       };
96696     } catch (Dali::DaliException e) {
96697       {
96698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96699       };
96700     } catch (...) {
96701       {
96702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96703       };
96704     }
96705   }
96706
96707 }
96708
96709
96710 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusGroupChangedSignal() {
96711   void * jresult ;
96712   Dali::Signal< void (Dali::Actor,bool) > *result = 0 ;
96713
96714   {
96715     try {
96716       result = (Dali::Signal< void (Dali::Actor,bool) > *)new Dali::Signal< void (Dali::Actor,bool) >();
96717     } catch (std::out_of_range& e) {
96718       {
96719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96720       };
96721     } catch (std::exception& e) {
96722       {
96723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96724       };
96725     } catch (Dali::DaliException e) {
96726       {
96727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96728       };
96729     } catch (...) {
96730       {
96731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96732       };
96733     }
96734   }
96735
96736   jresult = (void *)result;
96737   return jresult;
96738 }
96739
96740
96741 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusGroupChangedSignal(void * jarg1) {
96742   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96743
96744   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96745   {
96746     try {
96747       delete arg1;
96748     } catch (std::out_of_range& e) {
96749       {
96750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96751       };
96752     } catch (std::exception& e) {
96753       {
96754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96755       };
96756     } catch (Dali::DaliException e) {
96757       {
96758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96759       };
96760     } catch (...) {
96761       {
96762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96763       };
96764     }
96765   }
96766
96767 }
96768
96769
96770 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Empty(void * jarg1) {
96771   unsigned int jresult ;
96772   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96773   bool result;
96774
96775   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96776   {
96777     try {
96778       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);
96779     } catch (std::out_of_range& e) {
96780       {
96781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96782       };
96783     } catch (std::exception& e) {
96784       {
96785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96786       };
96787     } catch (Dali::DaliException e) {
96788       {
96789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96790       };
96791     } catch (...) {
96792       {
96793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96794       };
96795     }
96796   }
96797
96798   jresult = result;
96799   return jresult;
96800 }
96801
96802
96803 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StyleChangedSignal_GetConnectionCount(void * jarg1) {
96804   unsigned long jresult ;
96805   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96806   std::size_t result;
96807
96808   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96809   {
96810     try {
96811       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);
96812     } catch (std::out_of_range& e) {
96813       {
96814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96815       };
96816     } catch (std::exception& e) {
96817       {
96818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96819       };
96820     } catch (Dali::DaliException e) {
96821       {
96822         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96823       };
96824     } catch (...) {
96825       {
96826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96827       };
96828     }
96829   }
96830
96831   jresult = (unsigned long)result;
96832   return jresult;
96833 }
96834
96835
96836 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Connect(void * jarg1, void * jarg2) {
96837   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96838   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
96839
96840   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96841   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
96842   {
96843     try {
96844       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(arg1,arg2);
96845     } catch (std::out_of_range& e) {
96846       {
96847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96848       };
96849     } catch (std::exception& e) {
96850       {
96851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96852       };
96853     } catch (Dali::DaliException e) {
96854       {
96855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96856       };
96857     } catch (...) {
96858       {
96859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96860       };
96861     }
96862   }
96863
96864 }
96865
96866
96867 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Disconnect(void * jarg1, void * jarg2) {
96868   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96869   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
96870
96871   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96872   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
96873   {
96874     try {
96875       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(arg1,arg2);
96876     } catch (std::out_of_range& e) {
96877       {
96878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96879       };
96880     } catch (std::exception& e) {
96881       {
96882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96883       };
96884     } catch (Dali::DaliException e) {
96885       {
96886         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96887       };
96888     } catch (...) {
96889       {
96890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96891       };
96892     }
96893   }
96894
96895 }
96896
96897
96898 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
96899   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96900   Dali::Toolkit::StyleManager arg2 ;
96901   Dali::StyleChange::Type arg3 ;
96902   Dali::Toolkit::StyleManager *argp2 ;
96903
96904   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96905   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
96906   if (!argp2) {
96907     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
96908     return ;
96909   }
96910   arg2 = *argp2;
96911   arg3 = (Dali::StyleChange::Type)jarg3;
96912   {
96913     try {
96914       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(arg1,arg2,arg3);
96915     } catch (std::out_of_range& e) {
96916       {
96917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96918       };
96919     } catch (std::exception& e) {
96920       {
96921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96922       };
96923     } catch (Dali::DaliException e) {
96924       {
96925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96926       };
96927     } catch (...) {
96928       {
96929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96930       };
96931     }
96932   }
96933
96934 }
96935
96936
96937 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleChangedSignal() {
96938   void * jresult ;
96939   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *result = 0 ;
96940
96941   {
96942     try {
96943       result = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)new Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) >();
96944     } catch (std::out_of_range& e) {
96945       {
96946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96947       };
96948     } catch (std::exception& e) {
96949       {
96950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96951       };
96952     } catch (Dali::DaliException e) {
96953       {
96954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96955       };
96956     } catch (...) {
96957       {
96958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96959       };
96960     }
96961   }
96962
96963   jresult = (void *)result;
96964   return jresult;
96965 }
96966
96967
96968 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleChangedSignal(void * jarg1) {
96969   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96970
96971   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96972   {
96973     try {
96974       delete arg1;
96975     } catch (std::out_of_range& e) {
96976       {
96977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96978       };
96979     } catch (std::exception& e) {
96980       {
96981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96982       };
96983     } catch (Dali::DaliException e) {
96984       {
96985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96986       };
96987     } catch (...) {
96988       {
96989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96990       };
96991     }
96992   }
96993
96994 }
96995
96996
96997 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Empty(void * jarg1) {
96998   unsigned int jresult ;
96999   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
97000   bool result;
97001
97002   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
97003   {
97004     try {
97005       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
97006     } catch (std::out_of_range& e) {
97007       {
97008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97009       };
97010     } catch (std::exception& e) {
97011       {
97012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97013       };
97014     } catch (Dali::DaliException e) {
97015       {
97016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97017       };
97018     } catch (...) {
97019       {
97020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97021       };
97022     }
97023   }
97024
97025   jresult = result;
97026   return jresult;
97027 }
97028
97029
97030 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ButtonSignal_GetConnectionCount(void * jarg1) {
97031   unsigned long jresult ;
97032   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
97033   std::size_t result;
97034
97035   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
97036   {
97037     try {
97038       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
97039     } catch (std::out_of_range& e) {
97040       {
97041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97042       };
97043     } catch (std::exception& e) {
97044       {
97045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97046       };
97047     } catch (Dali::DaliException e) {
97048       {
97049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97050       };
97051     } catch (...) {
97052       {
97053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97054       };
97055     }
97056   }
97057
97058   jresult = (unsigned long)result;
97059   return jresult;
97060 }
97061
97062
97063 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Connect(void * jarg1, void * jarg2) {
97064   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
97065   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
97066
97067   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
97068   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
97069   {
97070     try {
97071       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(arg1,arg2);
97072     } catch (std::out_of_range& e) {
97073       {
97074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97075       };
97076     } catch (std::exception& e) {
97077       {
97078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97079       };
97080     } catch (Dali::DaliException e) {
97081       {
97082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97083       };
97084     } catch (...) {
97085       {
97086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97087       };
97088     }
97089   }
97090
97091 }
97092
97093
97094 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Disconnect(void * jarg1, void * jarg2) {
97095   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
97096   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
97097
97098   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
97099   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
97100   {
97101     try {
97102       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(arg1,arg2);
97103     } catch (std::out_of_range& e) {
97104       {
97105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97106       };
97107     } catch (std::exception& e) {
97108       {
97109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97110       };
97111     } catch (Dali::DaliException e) {
97112       {
97113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97114       };
97115     } catch (...) {
97116       {
97117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97118       };
97119     }
97120   }
97121
97122 }
97123
97124
97125 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Emit(void * jarg1, void * jarg2) {
97126   unsigned int jresult ;
97127   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
97128   Dali::Toolkit::Button arg2 ;
97129   Dali::Toolkit::Button *argp2 ;
97130   bool result;
97131
97132   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
97133   argp2 = (Dali::Toolkit::Button *)jarg2;
97134   if (!argp2) {
97135     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Button", 0);
97136     return 0;
97137   }
97138   arg2 = *argp2;
97139   {
97140     try {
97141       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(arg1,arg2);
97142     } catch (std::out_of_range& e) {
97143       {
97144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97145       };
97146     } catch (std::exception& e) {
97147       {
97148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97149       };
97150     } catch (Dali::DaliException e) {
97151       {
97152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97153       };
97154     } catch (...) {
97155       {
97156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97157       };
97158     }
97159   }
97160
97161   jresult = result;
97162   return jresult;
97163 }
97164
97165
97166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ButtonSignal() {
97167   void * jresult ;
97168   Dali::Signal< bool (Dali::Toolkit::Button) > *result = 0 ;
97169
97170   {
97171     try {
97172       result = (Dali::Signal< bool (Dali::Toolkit::Button) > *)new Dali::Signal< bool (Dali::Toolkit::Button) >();
97173     } catch (std::out_of_range& e) {
97174       {
97175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97176       };
97177     } catch (std::exception& e) {
97178       {
97179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97180       };
97181     } catch (Dali::DaliException e) {
97182       {
97183         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97184       };
97185     } catch (...) {
97186       {
97187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97188       };
97189     }
97190   }
97191
97192   jresult = (void *)result;
97193   return jresult;
97194 }
97195
97196
97197 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ButtonSignal(void * jarg1) {
97198   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
97199
97200   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
97201   {
97202     try {
97203       delete arg1;
97204     } catch (std::out_of_range& e) {
97205       {
97206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97207       };
97208     } catch (std::exception& e) {
97209       {
97210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97211       };
97212     } catch (Dali::DaliException e) {
97213       {
97214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97215       };
97216     } catch (...) {
97217       {
97218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97219       };
97220     }
97221   }
97222
97223 }
97224
97225
97226 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Empty(void * jarg1) {
97227   unsigned int jresult ;
97228   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
97229   bool result;
97230
97231   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
97232   {
97233     try {
97234       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
97235     } catch (std::out_of_range& e) {
97236       {
97237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97238       };
97239     } catch (std::exception& e) {
97240       {
97241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97242       };
97243     } catch (Dali::DaliException e) {
97244       {
97245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97246       };
97247     } catch (...) {
97248       {
97249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97250       };
97251     }
97252   }
97253
97254   jresult = result;
97255   return jresult;
97256 }
97257
97258
97259 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_GetConnectionCount(void * jarg1) {
97260   unsigned long jresult ;
97261   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
97262   std::size_t result;
97263
97264   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
97265   {
97266     try {
97267       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
97268     } catch (std::out_of_range& e) {
97269       {
97270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97271       };
97272     } catch (std::exception& e) {
97273       {
97274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97275       };
97276     } catch (Dali::DaliException e) {
97277       {
97278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97279       };
97280     } catch (...) {
97281       {
97282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97283       };
97284     }
97285   }
97286
97287   jresult = (unsigned long)result;
97288   return jresult;
97289 }
97290
97291
97292 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Connect(void * jarg1, void * jarg2) {
97293   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
97294   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
97295
97296   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
97297   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
97298   {
97299     try {
97300       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(arg1,arg2);
97301     } catch (std::out_of_range& e) {
97302       {
97303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97304       };
97305     } catch (std::exception& e) {
97306       {
97307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97308       };
97309     } catch (Dali::DaliException e) {
97310       {
97311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97312       };
97313     } catch (...) {
97314       {
97315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97316       };
97317     }
97318   }
97319
97320 }
97321
97322
97323 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Disconnect(void * jarg1, void * jarg2) {
97324   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
97325   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
97326
97327   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
97328   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
97329   {
97330     try {
97331       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(arg1,arg2);
97332     } catch (std::out_of_range& e) {
97333       {
97334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97335       };
97336     } catch (std::exception& e) {
97337       {
97338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97339       };
97340     } catch (Dali::DaliException e) {
97341       {
97342         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97343       };
97344     } catch (...) {
97345       {
97346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97347       };
97348     }
97349   }
97350
97351 }
97352
97353
97354 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Emit(void * jarg1, void * jarg2) {
97355   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
97356   Dali::Toolkit::GaussianBlurView arg2 ;
97357   Dali::Toolkit::GaussianBlurView *argp2 ;
97358
97359   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
97360   argp2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
97361   if (!argp2) {
97362     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::GaussianBlurView", 0);
97363     return ;
97364   }
97365   arg2 = *argp2;
97366   {
97367     try {
97368       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(arg1,arg2);
97369     } catch (std::out_of_range& e) {
97370       {
97371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97372       };
97373     } catch (std::exception& e) {
97374       {
97375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97376       };
97377     } catch (Dali::DaliException e) {
97378       {
97379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97380       };
97381     } catch (...) {
97382       {
97383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97384       };
97385     }
97386   }
97387
97388 }
97389
97390
97391 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurViewSignal() {
97392   void * jresult ;
97393   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *result = 0 ;
97394
97395   {
97396     try {
97397       result = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)new Dali::Signal< void (Dali::Toolkit::GaussianBlurView) >();
97398     } catch (std::out_of_range& e) {
97399       {
97400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97401       };
97402     } catch (std::exception& e) {
97403       {
97404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97405       };
97406     } catch (Dali::DaliException e) {
97407       {
97408         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97409       };
97410     } catch (...) {
97411       {
97412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97413       };
97414     }
97415   }
97416
97417   jresult = (void *)result;
97418   return jresult;
97419 }
97420
97421
97422 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurViewSignal(void * jarg1) {
97423   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
97424
97425   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
97426   {
97427     try {
97428       delete arg1;
97429     } catch (std::out_of_range& e) {
97430       {
97431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97432       };
97433     } catch (std::exception& e) {
97434       {
97435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97436       };
97437     } catch (Dali::DaliException e) {
97438       {
97439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97440       };
97441     } catch (...) {
97442       {
97443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97444       };
97445     }
97446   }
97447
97448 }
97449
97450
97451 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageTurnSignal_Empty(void * jarg1) {
97452   unsigned int jresult ;
97453   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
97454   bool result;
97455
97456   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
97457   {
97458     try {
97459       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);
97460     } catch (std::out_of_range& e) {
97461       {
97462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97463       };
97464     } catch (std::exception& e) {
97465       {
97466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97467       };
97468     } catch (Dali::DaliException e) {
97469       {
97470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97471       };
97472     } catch (...) {
97473       {
97474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97475       };
97476     }
97477   }
97478
97479   jresult = result;
97480   return jresult;
97481 }
97482
97483
97484 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PageTurnSignal_GetConnectionCount(void * jarg1) {
97485   unsigned long jresult ;
97486   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
97487   std::size_t result;
97488
97489   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
97490   {
97491     try {
97492       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);
97493     } catch (std::out_of_range& e) {
97494       {
97495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97496       };
97497     } catch (std::exception& e) {
97498       {
97499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97500       };
97501     } catch (Dali::DaliException e) {
97502       {
97503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97504       };
97505     } catch (...) {
97506       {
97507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97508       };
97509     }
97510   }
97511
97512   jresult = (unsigned long)result;
97513   return jresult;
97514 }
97515
97516
97517 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Connect(void * jarg1, void * jarg2) {
97518   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
97519   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
97520
97521   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
97522   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
97523   {
97524     try {
97525       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(arg1,arg2);
97526     } catch (std::out_of_range& e) {
97527       {
97528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97529       };
97530     } catch (std::exception& e) {
97531       {
97532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97533       };
97534     } catch (Dali::DaliException e) {
97535       {
97536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97537       };
97538     } catch (...) {
97539       {
97540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97541       };
97542     }
97543   }
97544
97545 }
97546
97547
97548 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Disconnect(void * jarg1, void * jarg2) {
97549   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
97550   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
97551
97552   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
97553   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
97554   {
97555     try {
97556       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
97557     } catch (std::out_of_range& e) {
97558       {
97559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97560       };
97561     } catch (std::exception& e) {
97562       {
97563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97564       };
97565     } catch (Dali::DaliException e) {
97566       {
97567         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97568       };
97569     } catch (...) {
97570       {
97571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97572       };
97573     }
97574   }
97575
97576 }
97577
97578
97579 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
97580   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
97581   Dali::Toolkit::PageTurnView arg2 ;
97582   unsigned int arg3 ;
97583   bool arg4 ;
97584   Dali::Toolkit::PageTurnView *argp2 ;
97585
97586   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
97587   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
97588   if (!argp2) {
97589     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
97590     return ;
97591   }
97592   arg2 = *argp2;
97593   arg3 = (unsigned int)jarg3;
97594   arg4 = jarg4 ? true : false;
97595   {
97596     try {
97597       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3,arg4);
97598     } catch (std::out_of_range& e) {
97599       {
97600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97601       };
97602     } catch (std::exception& e) {
97603       {
97604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97605       };
97606     } catch (Dali::DaliException e) {
97607       {
97608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97609       };
97610     } catch (...) {
97611       {
97612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97613       };
97614     }
97615   }
97616
97617 }
97618
97619
97620 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnSignal() {
97621   void * jresult ;
97622   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *result = 0 ;
97623
97624   {
97625     try {
97626       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) >();
97627     } catch (std::out_of_range& e) {
97628       {
97629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97630       };
97631     } catch (std::exception& e) {
97632       {
97633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97634       };
97635     } catch (Dali::DaliException e) {
97636       {
97637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97638       };
97639     } catch (...) {
97640       {
97641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97642       };
97643     }
97644   }
97645
97646   jresult = (void *)result;
97647   return jresult;
97648 }
97649
97650
97651 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnSignal(void * jarg1) {
97652   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
97653
97654   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
97655   {
97656     try {
97657       delete arg1;
97658     } catch (std::out_of_range& e) {
97659       {
97660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97661       };
97662     } catch (std::exception& e) {
97663       {
97664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97665       };
97666     } catch (Dali::DaliException e) {
97667       {
97668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97669       };
97670     } catch (...) {
97671       {
97672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97673       };
97674     }
97675   }
97676
97677 }
97678
97679
97680 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PagePanSignal_Empty(void * jarg1) {
97681   unsigned int jresult ;
97682   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97683   bool result;
97684
97685   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97686   {
97687     try {
97688       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
97689     } catch (std::out_of_range& e) {
97690       {
97691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97692       };
97693     } catch (std::exception& e) {
97694       {
97695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97696       };
97697     } catch (Dali::DaliException e) {
97698       {
97699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97700       };
97701     } catch (...) {
97702       {
97703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97704       };
97705     }
97706   }
97707
97708   jresult = result;
97709   return jresult;
97710 }
97711
97712
97713 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PagePanSignal_GetConnectionCount(void * jarg1) {
97714   unsigned long jresult ;
97715   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97716   std::size_t result;
97717
97718   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97719   {
97720     try {
97721       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
97722     } catch (std::out_of_range& e) {
97723       {
97724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97725       };
97726     } catch (std::exception& e) {
97727       {
97728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97729       };
97730     } catch (Dali::DaliException e) {
97731       {
97732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97733       };
97734     } catch (...) {
97735       {
97736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97737       };
97738     }
97739   }
97740
97741   jresult = (unsigned long)result;
97742   return jresult;
97743 }
97744
97745
97746 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Connect(void * jarg1, void * jarg2) {
97747   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97748   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
97749
97750   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97751   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
97752   {
97753     try {
97754       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(arg1,arg2);
97755     } catch (std::out_of_range& e) {
97756       {
97757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97758       };
97759     } catch (std::exception& e) {
97760       {
97761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97762       };
97763     } catch (Dali::DaliException e) {
97764       {
97765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97766       };
97767     } catch (...) {
97768       {
97769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97770       };
97771     }
97772   }
97773
97774 }
97775
97776
97777 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Disconnect(void * jarg1, void * jarg2) {
97778   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97779   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
97780
97781   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97782   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
97783   {
97784     try {
97785       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(arg1,arg2);
97786     } catch (std::out_of_range& e) {
97787       {
97788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97789       };
97790     } catch (std::exception& e) {
97791       {
97792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97793       };
97794     } catch (Dali::DaliException e) {
97795       {
97796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97797       };
97798     } catch (...) {
97799       {
97800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97801       };
97802     }
97803   }
97804
97805 }
97806
97807
97808 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Emit(void * jarg1, void * jarg2) {
97809   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97810   Dali::Toolkit::PageTurnView arg2 ;
97811   Dali::Toolkit::PageTurnView *argp2 ;
97812
97813   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97814   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
97815   if (!argp2) {
97816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
97817     return ;
97818   }
97819   arg2 = *argp2;
97820   {
97821     try {
97822       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(arg1,arg2);
97823     } catch (std::out_of_range& e) {
97824       {
97825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97826       };
97827     } catch (std::exception& e) {
97828       {
97829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97830       };
97831     } catch (Dali::DaliException e) {
97832       {
97833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97834       };
97835     } catch (...) {
97836       {
97837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97838       };
97839     }
97840   }
97841
97842 }
97843
97844
97845 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PagePanSignal() {
97846   void * jresult ;
97847   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *result = 0 ;
97848
97849   {
97850     try {
97851       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView) >();
97852     } catch (std::out_of_range& e) {
97853       {
97854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97855       };
97856     } catch (std::exception& e) {
97857       {
97858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97859       };
97860     } catch (Dali::DaliException e) {
97861       {
97862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97863       };
97864     } catch (...) {
97865       {
97866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97867       };
97868     }
97869   }
97870
97871   jresult = (void *)result;
97872   return jresult;
97873 }
97874
97875
97876 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PagePanSignal(void * jarg1) {
97877   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97878
97879   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97880   {
97881     try {
97882       delete arg1;
97883     } catch (std::out_of_range& e) {
97884       {
97885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97886       };
97887     } catch (std::exception& e) {
97888       {
97889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97890       };
97891     } catch (Dali::DaliException e) {
97892       {
97893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97894       };
97895     } catch (...) {
97896       {
97897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97898       };
97899     }
97900   }
97901
97902 }
97903
97904
97905 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Empty(void * jarg1) {
97906   unsigned int jresult ;
97907   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97908   bool result;
97909
97910   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97911   {
97912     try {
97913       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);
97914     } catch (std::out_of_range& e) {
97915       {
97916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97917       };
97918     } catch (std::exception& e) {
97919       {
97920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97921       };
97922     } catch (Dali::DaliException e) {
97923       {
97924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97925       };
97926     } catch (...) {
97927       {
97928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97929       };
97930     }
97931   }
97932
97933   jresult = result;
97934   return jresult;
97935 }
97936
97937
97938 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_GetConnectionCount(void * jarg1) {
97939   unsigned long jresult ;
97940   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97941   std::size_t result;
97942
97943   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97944   {
97945     try {
97946       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);
97947     } catch (std::out_of_range& e) {
97948       {
97949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97950       };
97951     } catch (std::exception& e) {
97952       {
97953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97954       };
97955     } catch (Dali::DaliException e) {
97956       {
97957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97958       };
97959     } catch (...) {
97960       {
97961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97962       };
97963     }
97964   }
97965
97966   jresult = (unsigned long)result;
97967   return jresult;
97968 }
97969
97970
97971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Connect(void * jarg1, void * jarg2) {
97972   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97973   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
97974
97975   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97976   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
97977   {
97978     try {
97979       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(arg1,arg2);
97980     } catch (std::out_of_range& e) {
97981       {
97982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97983       };
97984     } catch (std::exception& e) {
97985       {
97986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97987       };
97988     } catch (Dali::DaliException e) {
97989       {
97990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97991       };
97992     } catch (...) {
97993       {
97994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97995       };
97996     }
97997   }
97998
97999 }
98000
98001
98002 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
98003   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
98004   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
98005
98006   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
98007   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
98008   {
98009     try {
98010       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(arg1,arg2);
98011     } catch (std::out_of_range& e) {
98012       {
98013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98014       };
98015     } catch (std::exception& e) {
98016       {
98017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98018       };
98019     } catch (Dali::DaliException e) {
98020       {
98021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98022       };
98023     } catch (...) {
98024       {
98025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98026       };
98027     }
98028   }
98029
98030 }
98031
98032
98033 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3, float jarg4) {
98034   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
98035   Dali::Toolkit::ProgressBar arg2 ;
98036   float arg3 ;
98037   float arg4 ;
98038   Dali::Toolkit::ProgressBar *argp2 ;
98039
98040   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
98041   argp2 = (Dali::Toolkit::ProgressBar *)jarg2;
98042   if (!argp2) {
98043     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ProgressBar", 0);
98044     return ;
98045   }
98046   arg2 = *argp2;
98047   arg3 = (float)jarg3;
98048   arg4 = (float)jarg4;
98049   {
98050     try {
98051       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(arg1,arg2,arg3,arg4);
98052     } catch (std::out_of_range& e) {
98053       {
98054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98055       };
98056     } catch (std::exception& e) {
98057       {
98058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98059       };
98060     } catch (Dali::DaliException e) {
98061       {
98062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98063       };
98064     } catch (...) {
98065       {
98066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98067       };
98068     }
98069   }
98070
98071 }
98072
98073
98074 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBarValueChangedSignal() {
98075   void * jresult ;
98076   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *result = 0 ;
98077
98078   {
98079     try {
98080       result = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)new Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) >();
98081     } catch (std::out_of_range& e) {
98082       {
98083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98084       };
98085     } catch (std::exception& e) {
98086       {
98087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98088       };
98089     } catch (Dali::DaliException e) {
98090       {
98091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98092       };
98093     } catch (...) {
98094       {
98095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98096       };
98097     }
98098   }
98099
98100   jresult = (void *)result;
98101   return jresult;
98102 }
98103
98104
98105 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBarValueChangedSignal(void * jarg1) {
98106   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
98107
98108   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
98109   {
98110     try {
98111       delete arg1;
98112     } catch (std::out_of_range& e) {
98113       {
98114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98115       };
98116     } catch (std::exception& e) {
98117       {
98118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98119       };
98120     } catch (Dali::DaliException e) {
98121       {
98122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98123       };
98124     } catch (...) {
98125       {
98126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98127       };
98128     }
98129   }
98130
98131 }
98132
98133
98134 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Empty(void * jarg1) {
98135   unsigned int jresult ;
98136   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
98137   bool result;
98138
98139   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
98140   {
98141     try {
98142       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);
98143     } catch (std::out_of_range& e) {
98144       {
98145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98146       };
98147     } catch (std::exception& e) {
98148       {
98149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98150       };
98151     } catch (Dali::DaliException e) {
98152       {
98153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98154       };
98155     } catch (...) {
98156       {
98157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98158       };
98159     }
98160   }
98161
98162   jresult = result;
98163   return jresult;
98164 }
98165
98166
98167 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_GetConnectionCount(void * jarg1) {
98168   unsigned long jresult ;
98169   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
98170   std::size_t result;
98171
98172   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
98173   {
98174     try {
98175       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);
98176     } catch (std::out_of_range& e) {
98177       {
98178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98179       };
98180     } catch (std::exception& e) {
98181       {
98182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98183       };
98184     } catch (Dali::DaliException e) {
98185       {
98186         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98187       };
98188     } catch (...) {
98189       {
98190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98191       };
98192     }
98193   }
98194
98195   jresult = (unsigned long)result;
98196   return jresult;
98197 }
98198
98199
98200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Connect(void * jarg1, void * jarg2) {
98201   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
98202   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
98203
98204   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
98205   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
98206   {
98207     try {
98208       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
98209     } catch (std::out_of_range& e) {
98210       {
98211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98212       };
98213     } catch (std::exception& e) {
98214       {
98215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98216       };
98217     } catch (Dali::DaliException e) {
98218       {
98219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98220       };
98221     } catch (...) {
98222       {
98223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98224       };
98225     }
98226   }
98227
98228 }
98229
98230
98231 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Disconnect(void * jarg1, void * jarg2) {
98232   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
98233   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
98234
98235   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
98236   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
98237   {
98238     try {
98239       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
98240     } catch (std::out_of_range& e) {
98241       {
98242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98243       };
98244     } catch (std::exception& e) {
98245       {
98246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98247       };
98248     } catch (Dali::DaliException e) {
98249       {
98250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98251       };
98252     } catch (...) {
98253       {
98254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98255       };
98256     }
98257   }
98258
98259 }
98260
98261
98262 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Emit(void * jarg1, void * jarg2) {
98263   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
98264   Dali::Toolkit::ScrollView::SnapEvent *arg2 = 0 ;
98265
98266   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
98267   arg2 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg2;
98268   if (!arg2) {
98269     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView::SnapEvent const & type is null", 0);
98270     return ;
98271   }
98272   {
98273     try {
98274       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Toolkit::ScrollView::SnapEvent const &)*arg2);
98275     } catch (std::out_of_range& e) {
98276       {
98277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98278       };
98279     } catch (std::exception& e) {
98280       {
98281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98282       };
98283     } catch (Dali::DaliException e) {
98284       {
98285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98286       };
98287     } catch (...) {
98288       {
98289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98290       };
98291     }
98292   }
98293
98294 }
98295
98296
98297 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewSnapStartedSignal() {
98298   void * jresult ;
98299   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *result = 0 ;
98300
98301   {
98302     try {
98303       result = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)new Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) >();
98304     } catch (std::out_of_range& e) {
98305       {
98306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98307       };
98308     } catch (std::exception& e) {
98309       {
98310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98311       };
98312     } catch (Dali::DaliException e) {
98313       {
98314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98315       };
98316     } catch (...) {
98317       {
98318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98319       };
98320     }
98321   }
98322
98323   jresult = (void *)result;
98324   return jresult;
98325 }
98326
98327
98328 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewSnapStartedSignal(void * jarg1) {
98329   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
98330
98331   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
98332   {
98333     try {
98334       delete arg1;
98335     } catch (std::out_of_range& e) {
98336       {
98337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98338       };
98339     } catch (std::exception& e) {
98340       {
98341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98342       };
98343     } catch (Dali::DaliException e) {
98344       {
98345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98346       };
98347     } catch (...) {
98348       {
98349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98350       };
98351     }
98352   }
98353
98354 }
98355
98356
98357 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollableSignal_Empty(void * jarg1) {
98358   unsigned int jresult ;
98359   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
98360   bool result;
98361
98362   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
98363   {
98364     try {
98365       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
98366     } catch (std::out_of_range& e) {
98367       {
98368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98369       };
98370     } catch (std::exception& e) {
98371       {
98372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98373       };
98374     } catch (Dali::DaliException e) {
98375       {
98376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98377       };
98378     } catch (...) {
98379       {
98380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98381       };
98382     }
98383   }
98384
98385   jresult = result;
98386   return jresult;
98387 }
98388
98389
98390 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollableSignal_GetConnectionCount(void * jarg1) {
98391   unsigned long jresult ;
98392   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
98393   std::size_t result;
98394
98395   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
98396   {
98397     try {
98398       result = Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
98399     } catch (std::out_of_range& e) {
98400       {
98401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98402       };
98403     } catch (std::exception& e) {
98404       {
98405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98406       };
98407     } catch (Dali::DaliException e) {
98408       {
98409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98410       };
98411     } catch (...) {
98412       {
98413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98414       };
98415     }
98416   }
98417
98418   jresult = (unsigned long)result;
98419   return jresult;
98420 }
98421
98422
98423 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Connect(void * jarg1, void * jarg2) {
98424   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
98425   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
98426
98427   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
98428   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
98429   {
98430     try {
98431       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(arg1,arg2);
98432     } catch (std::out_of_range& e) {
98433       {
98434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98435       };
98436     } catch (std::exception& e) {
98437       {
98438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98439       };
98440     } catch (Dali::DaliException e) {
98441       {
98442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98443       };
98444     } catch (...) {
98445       {
98446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98447       };
98448     }
98449   }
98450
98451 }
98452
98453
98454 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Disconnect(void * jarg1, void * jarg2) {
98455   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
98456   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
98457
98458   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
98459   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
98460   {
98461     try {
98462       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
98463     } catch (std::out_of_range& e) {
98464       {
98465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98466       };
98467     } catch (std::exception& e) {
98468       {
98469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98470       };
98471     } catch (Dali::DaliException e) {
98472       {
98473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98474       };
98475     } catch (...) {
98476       {
98477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98478       };
98479     }
98480   }
98481
98482 }
98483
98484
98485 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Emit(void * jarg1, void * jarg2) {
98486   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
98487   Dali::Vector2 *arg2 = 0 ;
98488
98489   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
98490   arg2 = (Dali::Vector2 *)jarg2;
98491   if (!arg2) {
98492     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
98493     return ;
98494   }
98495   {
98496     try {
98497       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Vector2 const &)*arg2);
98498     } catch (std::out_of_range& e) {
98499       {
98500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98501       };
98502     } catch (std::exception& e) {
98503       {
98504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98505       };
98506     } catch (Dali::DaliException e) {
98507       {
98508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98509       };
98510     } catch (...) {
98511       {
98512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98513       };
98514     }
98515   }
98516
98517 }
98518
98519
98520 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollableSignal() {
98521   void * jresult ;
98522   Dali::Signal< void (Dali::Vector2 const &) > *result = 0 ;
98523
98524   {
98525     try {
98526       result = (Dali::Signal< void (Dali::Vector2 const &) > *)new Dali::Signal< void (Dali::Vector2 const &) >();
98527     } catch (std::out_of_range& e) {
98528       {
98529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98530       };
98531     } catch (std::exception& e) {
98532       {
98533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98534       };
98535     } catch (Dali::DaliException e) {
98536       {
98537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98538       };
98539     } catch (...) {
98540       {
98541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98542       };
98543     }
98544   }
98545
98546   jresult = (void *)result;
98547   return jresult;
98548 }
98549
98550
98551 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollableSignal(void * jarg1) {
98552   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
98553
98554   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
98555   {
98556     try {
98557       delete arg1;
98558     } catch (std::out_of_range& e) {
98559       {
98560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98561       };
98562     } catch (std::exception& e) {
98563       {
98564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98565       };
98566     } catch (Dali::DaliException e) {
98567       {
98568         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98569       };
98570     } catch (...) {
98571       {
98572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98573       };
98574     }
98575   }
98576
98577 }
98578
98579
98580
98581 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Empty(void * jarg1) {
98582   unsigned int jresult ;
98583   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98584   bool result;
98585
98586   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98587   {
98588     try {
98589       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);
98590     } catch (std::out_of_range& e) {
98591       {
98592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98593       };
98594     } catch (std::exception& e) {
98595       {
98596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98597       };
98598     } catch (Dali::DaliException e) {
98599       {
98600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98601       };
98602     } catch (...) {
98603       {
98604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98605       };
98606     }
98607   }
98608
98609   jresult = result;
98610   return jresult;
98611 }
98612
98613
98614 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ControlKeySignal_GetConnectionCount(void * jarg1) {
98615   unsigned long jresult ;
98616   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98617   std::size_t result;
98618
98619   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98620   {
98621     try {
98622       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);
98623     } catch (std::out_of_range& e) {
98624       {
98625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98626       };
98627     } catch (std::exception& e) {
98628       {
98629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98630       };
98631     } catch (Dali::DaliException e) {
98632       {
98633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98634       };
98635     } catch (...) {
98636       {
98637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98638       };
98639     }
98640   }
98641
98642   jresult = (unsigned long)result;
98643   return jresult;
98644 }
98645
98646
98647 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Connect(void * jarg1, void * jarg2) {
98648   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98649   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
98650
98651   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98652   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
98653   {
98654     try {
98655       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
98656     } catch (std::out_of_range& e) {
98657       {
98658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98659       };
98660     } catch (std::exception& e) {
98661       {
98662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98663       };
98664     } catch (Dali::DaliException e) {
98665       {
98666         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98667       };
98668     } catch (...) {
98669       {
98670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98671       };
98672     }
98673   }
98674
98675 }
98676
98677
98678 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Disconnect(void * jarg1, void * jarg2) {
98679   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98680   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
98681
98682   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98683   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
98684   {
98685     try {
98686       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
98687     } catch (std::out_of_range& e) {
98688       {
98689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98690       };
98691     } catch (std::exception& e) {
98692       {
98693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98694       };
98695     } catch (Dali::DaliException e) {
98696       {
98697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98698       };
98699     } catch (...) {
98700       {
98701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98702       };
98703     }
98704   }
98705
98706 }
98707
98708
98709 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
98710   unsigned int jresult ;
98711   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98712   Dali::Toolkit::Control arg2 ;
98713   Dali::KeyEvent *arg3 = 0 ;
98714   Dali::Toolkit::Control *argp2 ;
98715   bool result;
98716
98717   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98718   argp2 = (Dali::Toolkit::Control *)jarg2;
98719   if (!argp2) {
98720     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
98721     return 0;
98722   }
98723   arg2 = *argp2;
98724   arg3 = (Dali::KeyEvent *)jarg3;
98725   if (!arg3) {
98726     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
98727     return 0;
98728   }
98729   {
98730     try {
98731       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);
98732     } catch (std::out_of_range& e) {
98733       {
98734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98735       };
98736     } catch (std::exception& e) {
98737       {
98738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98739       };
98740     } catch (Dali::DaliException e) {
98741       {
98742         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98743       };
98744     } catch (...) {
98745       {
98746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98747       };
98748     }
98749   }
98750
98751   jresult = result;
98752   return jresult;
98753 }
98754
98755
98756 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ControlKeySignal() {
98757   void * jresult ;
98758   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *result = 0 ;
98759
98760   {
98761     try {
98762       result = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)new Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) >();
98763     } catch (std::out_of_range& e) {
98764       {
98765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98766       };
98767     } catch (std::exception& e) {
98768       {
98769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98770       };
98771     } catch (Dali::DaliException e) {
98772       {
98773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98774       };
98775     } catch (...) {
98776       {
98777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98778       };
98779     }
98780   }
98781
98782   jresult = (void *)result;
98783   return jresult;
98784 }
98785
98786
98787 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ControlKeySignal(void * jarg1) {
98788   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98789
98790   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98791   {
98792     try {
98793       delete arg1;
98794     } catch (std::out_of_range& e) {
98795       {
98796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98797       };
98798     } catch (std::exception& e) {
98799       {
98800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98801       };
98802     } catch (Dali::DaliException e) {
98803       {
98804         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98805       };
98806     } catch (...) {
98807       {
98808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98809       };
98810     }
98811   }
98812
98813 }
98814
98815
98816 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Empty(void * jarg1) {
98817   unsigned int jresult ;
98818   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98819   bool result;
98820
98821   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98822   {
98823     try {
98824       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
98825     } catch (std::out_of_range& e) {
98826       {
98827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98828       };
98829     } catch (std::exception& e) {
98830       {
98831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98832       };
98833     } catch (Dali::DaliException e) {
98834       {
98835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98836       };
98837     } catch (...) {
98838       {
98839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98840       };
98841     }
98842   }
98843
98844   jresult = result;
98845   return jresult;
98846 }
98847
98848
98849 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_GetConnectionCount(void * jarg1) {
98850   unsigned long jresult ;
98851   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98852   std::size_t result;
98853
98854   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98855   {
98856     try {
98857       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
98858     } catch (std::out_of_range& e) {
98859       {
98860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98861       };
98862     } catch (std::exception& e) {
98863       {
98864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98865       };
98866     } catch (Dali::DaliException e) {
98867       {
98868         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98869       };
98870     } catch (...) {
98871       {
98872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98873       };
98874     }
98875   }
98876
98877   jresult = (unsigned long)result;
98878   return jresult;
98879 }
98880
98881
98882 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Connect(void * jarg1, void * jarg2) {
98883   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98884   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
98885
98886   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98887   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
98888   {
98889     try {
98890       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
98891     } catch (std::out_of_range& e) {
98892       {
98893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98894       };
98895     } catch (std::exception& e) {
98896       {
98897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98898       };
98899     } catch (Dali::DaliException e) {
98900       {
98901         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98902       };
98903     } catch (...) {
98904       {
98905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98906       };
98907     }
98908   }
98909
98910 }
98911
98912
98913 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Disconnect(void * jarg1, void * jarg2) {
98914   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98915   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
98916
98917   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98918   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
98919   {
98920     try {
98921       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
98922     } catch (std::out_of_range& e) {
98923       {
98924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98925       };
98926     } catch (std::exception& e) {
98927       {
98928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98929       };
98930     } catch (Dali::DaliException e) {
98931       {
98932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98933       };
98934     } catch (...) {
98935       {
98936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98937       };
98938     }
98939   }
98940
98941 }
98942
98943
98944 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Emit(void * jarg1, void * jarg2) {
98945   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98946   Dali::Toolkit::Control arg2 ;
98947   Dali::Toolkit::Control *argp2 ;
98948
98949   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98950   argp2 = (Dali::Toolkit::Control *)jarg2;
98951   if (!argp2) {
98952     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
98953     return ;
98954   }
98955   arg2 = *argp2;
98956   {
98957     try {
98958       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
98959     } catch (std::out_of_range& e) {
98960       {
98961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98962       };
98963     } catch (std::exception& e) {
98964       {
98965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98966       };
98967     } catch (Dali::DaliException e) {
98968       {
98969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98970       };
98971     } catch (...) {
98972       {
98973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98974       };
98975     }
98976   }
98977
98978 }
98979
98980
98981 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusSignal() {
98982   void * jresult ;
98983   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
98984
98985   {
98986     try {
98987       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
98988     } catch (std::out_of_range& e) {
98989       {
98990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98991       };
98992     } catch (std::exception& e) {
98993       {
98994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98995       };
98996     } catch (Dali::DaliException e) {
98997       {
98998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98999       };
99000     } catch (...) {
99001       {
99002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99003       };
99004     }
99005   }
99006
99007   jresult = (void *)result;
99008   return jresult;
99009 }
99010
99011
99012 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusSignal(void * jarg1) {
99013   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
99014
99015   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
99016   {
99017     try {
99018       delete arg1;
99019     } catch (std::out_of_range& e) {
99020       {
99021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99022       };
99023     } catch (std::exception& e) {
99024       {
99025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99026       };
99027     } catch (Dali::DaliException e) {
99028       {
99029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99030       };
99031     } catch (...) {
99032       {
99033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99034       };
99035     }
99036   }
99037
99038 }
99039
99040
99041 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VideoViewSignal_Empty(void * jarg1) {
99042   unsigned int jresult ;
99043   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
99044   bool result;
99045
99046   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
99047   {
99048     try {
99049       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
99050     } catch (std::out_of_range& e) {
99051       {
99052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99053       };
99054     } catch (std::exception& e) {
99055       {
99056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99057       };
99058     } catch (Dali::DaliException e) {
99059       {
99060         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99061       };
99062     } catch (...) {
99063       {
99064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99065       };
99066     }
99067   }
99068
99069   jresult = result;
99070   return jresult;
99071 }
99072
99073
99074 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VideoViewSignal_GetConnectionCount(void * jarg1) {
99075   unsigned long jresult ;
99076   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
99077   std::size_t result;
99078
99079   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
99080   {
99081     try {
99082       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
99083     } catch (std::out_of_range& e) {
99084       {
99085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99086       };
99087     } catch (std::exception& e) {
99088       {
99089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99090       };
99091     } catch (Dali::DaliException e) {
99092       {
99093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99094       };
99095     } catch (...) {
99096       {
99097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99098       };
99099     }
99100   }
99101
99102   jresult = (unsigned long)result;
99103   return jresult;
99104 }
99105
99106
99107 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Connect(void * jarg1, void * jarg2) {
99108   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
99109   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
99110
99111   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
99112   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
99113   {
99114     try {
99115       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(arg1,arg2);
99116     } catch (std::out_of_range& e) {
99117       {
99118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99119       };
99120     } catch (std::exception& e) {
99121       {
99122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99123       };
99124     } catch (Dali::DaliException e) {
99125       {
99126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99127       };
99128     } catch (...) {
99129       {
99130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99131       };
99132     }
99133   }
99134
99135 }
99136
99137
99138 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Disconnect(void * jarg1, void * jarg2) {
99139   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
99140   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
99141
99142   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
99143   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
99144   {
99145     try {
99146       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(arg1,arg2);
99147     } catch (std::out_of_range& e) {
99148       {
99149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99150       };
99151     } catch (std::exception& e) {
99152       {
99153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99154       };
99155     } catch (Dali::DaliException e) {
99156       {
99157         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99158       };
99159     } catch (...) {
99160       {
99161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99162       };
99163     }
99164   }
99165
99166 }
99167
99168
99169 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Emit(void * jarg1, void * jarg2) {
99170   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
99171   Dali::Toolkit::VideoView *arg2 = 0 ;
99172
99173   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
99174   arg2 = (Dali::Toolkit::VideoView *)jarg2;
99175   if (!arg2) {
99176     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView & type is null", 0);
99177     return ;
99178   }
99179   {
99180     try {
99181       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(arg1,*arg2);
99182     } catch (std::out_of_range& e) {
99183       {
99184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99185       };
99186     } catch (std::exception& e) {
99187       {
99188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99189       };
99190     } catch (Dali::DaliException e) {
99191       {
99192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99193       };
99194     } catch (...) {
99195       {
99196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99197       };
99198     }
99199   }
99200
99201 }
99202
99203
99204 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoViewSignal() {
99205   void * jresult ;
99206   Dali::Signal< void (Dali::Toolkit::VideoView &) > *result = 0 ;
99207
99208   {
99209     try {
99210       result = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)new Dali::Signal< void (Dali::Toolkit::VideoView &) >();
99211     } catch (std::out_of_range& e) {
99212       {
99213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99214       };
99215     } catch (std::exception& e) {
99216       {
99217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99218       };
99219     } catch (Dali::DaliException e) {
99220       {
99221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99222       };
99223     } catch (...) {
99224       {
99225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99226       };
99227     }
99228   }
99229
99230   jresult = (void *)result;
99231   return jresult;
99232 }
99233
99234
99235 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoViewSignal(void * jarg1) {
99236   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
99237
99238   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
99239   {
99240     try {
99241       delete arg1;
99242     } catch (std::out_of_range& e) {
99243       {
99244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99245       };
99246     } catch (std::exception& e) {
99247       {
99248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99249       };
99250     } catch (Dali::DaliException e) {
99251       {
99252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99253       };
99254     } catch (...) {
99255       {
99256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99257       };
99258     }
99259   }
99260
99261 }
99262
99263
99264 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Empty(void * jarg1) {
99265   unsigned int jresult ;
99266   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
99267   bool result;
99268
99269   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
99270   {
99271     try {
99272       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
99273     } catch (std::out_of_range& e) {
99274       {
99275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99276       };
99277     } catch (std::exception& e) {
99278       {
99279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99280       };
99281     } catch (Dali::DaliException e) {
99282       {
99283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99284       };
99285     } catch (...) {
99286       {
99287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99288       };
99289     }
99290   }
99291
99292   jresult = result;
99293   return jresult;
99294 }
99295
99296
99297 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_GetConnectionCount(void * jarg1) {
99298   unsigned long jresult ;
99299   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
99300   std::size_t result;
99301
99302   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
99303   {
99304     try {
99305       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
99306     } catch (std::out_of_range& e) {
99307       {
99308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99309       };
99310     } catch (std::exception& e) {
99311       {
99312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99313       };
99314     } catch (Dali::DaliException e) {
99315       {
99316         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99317       };
99318     } catch (...) {
99319       {
99320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99321       };
99322     }
99323   }
99324
99325   jresult = (unsigned long)result;
99326   return jresult;
99327 }
99328
99329
99330 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Connect(void * jarg1, void * jarg2) {
99331   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
99332   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
99333
99334   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
99335   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
99336   {
99337     try {
99338       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(arg1,arg2);
99339     } catch (std::out_of_range& e) {
99340       {
99341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99342       };
99343     } catch (std::exception& e) {
99344       {
99345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99346       };
99347     } catch (Dali::DaliException e) {
99348       {
99349         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99350       };
99351     } catch (...) {
99352       {
99353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99354       };
99355     }
99356   }
99357
99358 }
99359
99360
99361 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
99362   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
99363   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
99364
99365   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
99366   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
99367   {
99368     try {
99369       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(arg1,arg2);
99370     } catch (std::out_of_range& e) {
99371       {
99372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99373       };
99374     } catch (std::exception& e) {
99375       {
99376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99377       };
99378     } catch (Dali::DaliException e) {
99379       {
99380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99381       };
99382     } catch (...) {
99383       {
99384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99385       };
99386     }
99387   }
99388
99389 }
99390
99391
99392 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3) {
99393   unsigned int jresult ;
99394   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
99395   Dali::Toolkit::Slider arg2 ;
99396   float arg3 ;
99397   Dali::Toolkit::Slider *argp2 ;
99398   bool result;
99399
99400   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
99401   argp2 = (Dali::Toolkit::Slider *)jarg2;
99402   if (!argp2) {
99403     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
99404     return 0;
99405   }
99406   arg2 = *argp2;
99407   arg3 = (float)jarg3;
99408   {
99409     try {
99410       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(arg1,arg2,arg3);
99411     } catch (std::out_of_range& e) {
99412       {
99413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99414       };
99415     } catch (std::exception& e) {
99416       {
99417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99418       };
99419     } catch (Dali::DaliException e) {
99420       {
99421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99422       };
99423     } catch (...) {
99424       {
99425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99426       };
99427     }
99428   }
99429
99430   jresult = result;
99431   return jresult;
99432 }
99433
99434
99435 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderValueChangedSignal() {
99436   void * jresult ;
99437   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *result = 0 ;
99438
99439   {
99440     try {
99441       result = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,float) >();
99442     } catch (std::out_of_range& e) {
99443       {
99444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99445       };
99446     } catch (std::exception& e) {
99447       {
99448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99449       };
99450     } catch (Dali::DaliException e) {
99451       {
99452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99453       };
99454     } catch (...) {
99455       {
99456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99457       };
99458     }
99459   }
99460
99461   jresult = (void *)result;
99462   return jresult;
99463 }
99464
99465
99466 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderValueChangedSignal(void * jarg1) {
99467   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
99468
99469   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
99470   {
99471     try {
99472       delete arg1;
99473     } catch (std::out_of_range& e) {
99474       {
99475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99476       };
99477     } catch (std::exception& e) {
99478       {
99479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99480       };
99481     } catch (Dali::DaliException e) {
99482       {
99483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99484       };
99485     } catch (...) {
99486       {
99487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99488       };
99489     }
99490   }
99491
99492 }
99493
99494
99495 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Empty(void * jarg1) {
99496   unsigned int jresult ;
99497   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99498   bool result;
99499
99500   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99501   {
99502     try {
99503       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
99504     } catch (std::out_of_range& e) {
99505       {
99506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99507       };
99508     } catch (std::exception& e) {
99509       {
99510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99511       };
99512     } catch (Dali::DaliException e) {
99513       {
99514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99515       };
99516     } catch (...) {
99517       {
99518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99519       };
99520     }
99521   }
99522
99523   jresult = result;
99524   return jresult;
99525 }
99526
99527
99528 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_GetConnectionCount(void * jarg1) {
99529   unsigned long jresult ;
99530   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99531   std::size_t result;
99532
99533   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99534   {
99535     try {
99536       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
99537     } catch (std::out_of_range& e) {
99538       {
99539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99540       };
99541     } catch (std::exception& e) {
99542       {
99543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99544       };
99545     } catch (Dali::DaliException e) {
99546       {
99547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99548       };
99549     } catch (...) {
99550       {
99551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99552       };
99553     }
99554   }
99555
99556   jresult = (unsigned long)result;
99557   return jresult;
99558 }
99559
99560
99561 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Connect(void * jarg1, void * jarg2) {
99562   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99563   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
99564
99565   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99566   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
99567   {
99568     try {
99569       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(arg1,arg2);
99570     } catch (std::out_of_range& e) {
99571       {
99572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99573       };
99574     } catch (std::exception& e) {
99575       {
99576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99577       };
99578     } catch (Dali::DaliException e) {
99579       {
99580         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99581       };
99582     } catch (...) {
99583       {
99584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99585       };
99586     }
99587   }
99588
99589 }
99590
99591
99592 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Disconnect(void * jarg1, void * jarg2) {
99593   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99594   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
99595
99596   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99597   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
99598   {
99599     try {
99600       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(arg1,arg2);
99601     } catch (std::out_of_range& e) {
99602       {
99603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99604       };
99605     } catch (std::exception& e) {
99606       {
99607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99608       };
99609     } catch (Dali::DaliException e) {
99610       {
99611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99612       };
99613     } catch (...) {
99614       {
99615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99616       };
99617     }
99618   }
99619
99620 }
99621
99622
99623 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
99624   unsigned int jresult ;
99625   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99626   Dali::Toolkit::Slider arg2 ;
99627   int arg3 ;
99628   Dali::Toolkit::Slider *argp2 ;
99629   bool result;
99630
99631   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99632   argp2 = (Dali::Toolkit::Slider *)jarg2;
99633   if (!argp2) {
99634     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
99635     return 0;
99636   }
99637   arg2 = *argp2;
99638   arg3 = (int)jarg3;
99639   {
99640     try {
99641       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(arg1,arg2,arg3);
99642     } catch (std::out_of_range& e) {
99643       {
99644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99645       };
99646     } catch (std::exception& e) {
99647       {
99648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99649       };
99650     } catch (Dali::DaliException e) {
99651       {
99652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99653       };
99654     } catch (...) {
99655       {
99656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99657       };
99658     }
99659   }
99660
99661   jresult = result;
99662   return jresult;
99663 }
99664
99665
99666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderMarkReachedSignal() {
99667   void * jresult ;
99668   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *result = 0 ;
99669
99670   {
99671     try {
99672       result = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,int) >();
99673     } catch (std::out_of_range& e) {
99674       {
99675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99676       };
99677     } catch (std::exception& e) {
99678       {
99679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99680       };
99681     } catch (Dali::DaliException e) {
99682       {
99683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99684       };
99685     } catch (...) {
99686       {
99687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99688       };
99689     }
99690   }
99691
99692   jresult = (void *)result;
99693   return jresult;
99694 }
99695
99696
99697 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderMarkReachedSignal(void * jarg1) {
99698   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99699
99700   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99701   {
99702     try {
99703       delete arg1;
99704     } catch (std::out_of_range& e) {
99705       {
99706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99707       };
99708     } catch (std::exception& e) {
99709       {
99710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99711       };
99712     } catch (Dali::DaliException e) {
99713       {
99714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99715       };
99716     } catch (...) {
99717       {
99718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99719       };
99720     }
99721   }
99722
99723 }
99724
99725
99726 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_0() {
99727   void * jresult ;
99728   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99729
99730   {
99731     try {
99732       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >();
99733     } catch (std::out_of_range& e) {
99734       {
99735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99736       };
99737     } catch (std::exception& e) {
99738       {
99739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99740       };
99741     } catch (Dali::DaliException e) {
99742       {
99743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99744       };
99745     } catch (...) {
99746       {
99747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99748       };
99749     }
99750   }
99751
99752   jresult = (void *)result;
99753   return jresult;
99754 }
99755
99756
99757 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_1(void * jarg1) {
99758   void * jresult ;
99759   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
99760   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99761
99762   arg1 = (Dali::Toolkit::Ruler *)jarg1;
99763   {
99764     try {
99765       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >(arg1);
99766     } catch (std::out_of_range& e) {
99767       {
99768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99769       };
99770     } catch (std::exception& e) {
99771       {
99772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99773       };
99774     } catch (Dali::DaliException e) {
99775       {
99776         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99777       };
99778     } catch (...) {
99779       {
99780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99781       };
99782     }
99783   }
99784
99785   jresult = (void *)result;
99786   return jresult;
99787 }
99788
99789
99790 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_2(void * jarg1) {
99791   void * jresult ;
99792   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = 0 ;
99793   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99794
99795   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99796   if (!arg1) {
99797     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
99798     return 0;
99799   }
99800   {
99801     try {
99802       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg1);
99803     } catch (std::out_of_range& e) {
99804       {
99805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99806       };
99807     } catch (std::exception& e) {
99808       {
99809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99810       };
99811     } catch (Dali::DaliException e) {
99812       {
99813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99814       };
99815     } catch (...) {
99816       {
99817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99818       };
99819     }
99820   }
99821
99822   jresult = (void *)result;
99823   return jresult;
99824 }
99825
99826
99827 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerPtr(void * jarg1) {
99828   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99829
99830   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99831   {
99832     try {
99833       delete arg1;
99834     } catch (std::out_of_range& e) {
99835       {
99836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99837       };
99838     } catch (std::exception& e) {
99839       {
99840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99841       };
99842     } catch (Dali::DaliException e) {
99843       {
99844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99845       };
99846     } catch (...) {
99847       {
99848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99849       };
99850     }
99851   }
99852
99853 }
99854
99855
99856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Get(void * jarg1) {
99857   void * jresult ;
99858   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99859   Dali::Toolkit::Ruler *result = 0 ;
99860
99861   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99862   {
99863     try {
99864       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->Get();
99865     } catch (std::out_of_range& e) {
99866       {
99867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99868       };
99869     } catch (std::exception& e) {
99870       {
99871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99872       };
99873     } catch (Dali::DaliException e) {
99874       {
99875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99876       };
99877     } catch (...) {
99878       {
99879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99880       };
99881     }
99882   }
99883
99884   jresult = (void *)result;
99885   return jresult;
99886 }
99887
99888
99889 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___deref__(void * jarg1) {
99890   void * jresult ;
99891   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99892   Dali::Toolkit::Ruler *result = 0 ;
99893
99894   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99895   {
99896     try {
99897       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator ->();
99898     } catch (std::out_of_range& e) {
99899       {
99900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99901       };
99902     } catch (std::exception& e) {
99903       {
99904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99905       };
99906     } catch (Dali::DaliException e) {
99907       {
99908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99909       };
99910     } catch (...) {
99911       {
99912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99913       };
99914     }
99915   }
99916
99917   jresult = (void *)result;
99918   return jresult;
99919 }
99920
99921
99922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___ref__(void * jarg1) {
99923   void * jresult ;
99924   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99925   Dali::Toolkit::Ruler *result = 0 ;
99926
99927   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99928   {
99929     try {
99930       result = (Dali::Toolkit::Ruler *) &((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator *();
99931     } catch (std::out_of_range& e) {
99932       {
99933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99934       };
99935     } catch (std::exception& e) {
99936       {
99937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99938       };
99939     } catch (Dali::DaliException e) {
99940       {
99941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99942       };
99943     } catch (...) {
99944       {
99945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99946       };
99947     }
99948   }
99949
99950   jresult = (void *)result;
99951   return jresult;
99952 }
99953
99954
99955 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_0(void * jarg1, void * jarg2) {
99956   void * jresult ;
99957   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99958   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg2 = 0 ;
99959   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99960
99961   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99962   arg2 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg2;
99963   if (!arg2) {
99964     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
99965     return 0;
99966   }
99967   {
99968     try {
99969       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg2);
99970     } catch (std::out_of_range& e) {
99971       {
99972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99973       };
99974     } catch (std::exception& e) {
99975       {
99976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99977       };
99978     } catch (Dali::DaliException e) {
99979       {
99980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99981       };
99982     } catch (...) {
99983       {
99984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99985       };
99986     }
99987   }
99988
99989   jresult = (void *)result;
99990   return jresult;
99991 }
99992
99993
99994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_1(void * jarg1, void * jarg2) {
99995   void * jresult ;
99996   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99997   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
99998   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99999
100000   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100001   arg2 = (Dali::Toolkit::Ruler *)jarg2;
100002   {
100003     try {
100004       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =(arg2);
100005     } catch (std::out_of_range& e) {
100006       {
100007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100008       };
100009     } catch (std::exception& e) {
100010       {
100011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100012       };
100013     } catch (Dali::DaliException e) {
100014       {
100015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100016       };
100017     } catch (...) {
100018       {
100019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100020       };
100021     }
100022   }
100023
100024   jresult = (void *)result;
100025   return jresult;
100026 }
100027
100028
100029 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_0(void * jarg1) {
100030   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100031
100032   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100033   {
100034     try {
100035       (arg1)->Reset();
100036     } catch (std::out_of_range& e) {
100037       {
100038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100039       };
100040     } catch (std::exception& e) {
100041       {
100042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100043       };
100044     } catch (Dali::DaliException e) {
100045       {
100046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100047       };
100048     } catch (...) {
100049       {
100050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100051       };
100052     }
100053   }
100054
100055 }
100056
100057
100058 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_1(void * jarg1, void * jarg2) {
100059   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100060   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
100061
100062   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100063   arg2 = (Dali::Toolkit::Ruler *)jarg2;
100064   {
100065     try {
100066       (arg1)->Reset(arg2);
100067     } catch (std::out_of_range& e) {
100068       {
100069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100070       };
100071     } catch (std::exception& e) {
100072       {
100073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100074       };
100075     } catch (Dali::DaliException e) {
100076       {
100077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100078       };
100079     } catch (...) {
100080       {
100081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100082       };
100083     }
100084   }
100085
100086 }
100087
100088
100089 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Detach(void * jarg1) {
100090   void * jresult ;
100091   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100092   Dali::Toolkit::Ruler *result = 0 ;
100093
100094   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100095   {
100096     try {
100097       result = (Dali::Toolkit::Ruler *)(arg1)->Detach();
100098     } catch (std::out_of_range& e) {
100099       {
100100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100101       };
100102     } catch (std::exception& e) {
100103       {
100104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100105       };
100106     } catch (Dali::DaliException e) {
100107       {
100108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100109       };
100110     } catch (...) {
100111       {
100112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100113       };
100114     }
100115   }
100116
100117   jresult = (void *)result;
100118   return jresult;
100119 }
100120
100121
100122 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
100123   float jresult ;
100124   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100125   float arg2 ;
100126   float arg3 ;
100127   float result;
100128
100129   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100130   arg2 = (float)jarg2;
100131   arg3 = (float)jarg3;
100132   {
100133     try {
100134       result = (float)(*arg1)->Snap(arg2,arg3);
100135     } catch (std::out_of_range& e) {
100136       {
100137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100138       };
100139     } catch (std::exception& e) {
100140       {
100141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100142       };
100143     } catch (Dali::DaliException e) {
100144       {
100145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100146       };
100147     } catch (...) {
100148       {
100149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100150       };
100151     }
100152   }
100153
100154   jresult = result;
100155   return jresult;
100156 }
100157
100158
100159 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_1(void * jarg1, float jarg2) {
100160   float jresult ;
100161   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100162   float arg2 ;
100163   float result;
100164
100165   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100166   arg2 = (float)jarg2;
100167   {
100168     try {
100169       result = (float)(*arg1)->Snap(arg2);
100170     } catch (std::out_of_range& e) {
100171       {
100172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100173       };
100174     } catch (std::exception& e) {
100175       {
100176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100177       };
100178     } catch (Dali::DaliException e) {
100179       {
100180         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100181       };
100182     } catch (...) {
100183       {
100184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100185       };
100186     }
100187   }
100188
100189   jresult = result;
100190   return jresult;
100191 }
100192
100193
100194 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
100195   float jresult ;
100196   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100197   unsigned int arg2 ;
100198   unsigned int *arg3 = 0 ;
100199   bool arg4 ;
100200   float result;
100201
100202   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100203   arg2 = (unsigned int)jarg2;
100204   arg3 = (unsigned int *)jarg3;
100205   arg4 = jarg4 ? true : false;
100206   {
100207     try {
100208       result = (float)(*arg1)->GetPositionFromPage(arg2,*arg3,arg4);
100209     } catch (std::out_of_range& e) {
100210       {
100211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100212       };
100213     } catch (std::exception& e) {
100214       {
100215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100216       };
100217     } catch (Dali::DaliException e) {
100218       {
100219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100220       };
100221     } catch (...) {
100222       {
100223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100224       };
100225     }
100226   }
100227
100228   jresult = result;
100229   return jresult;
100230 }
100231
100232
100233 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
100234   unsigned int jresult ;
100235   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100236   float arg2 ;
100237   bool arg3 ;
100238   unsigned int result;
100239
100240   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100241   arg2 = (float)jarg2;
100242   arg3 = jarg3 ? true : false;
100243   {
100244     try {
100245       result = (unsigned int)(*arg1)->GetPageFromPosition(arg2,arg3);
100246     } catch (std::out_of_range& e) {
100247       {
100248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100249       };
100250     } catch (std::exception& e) {
100251       {
100252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100253       };
100254     } catch (Dali::DaliException e) {
100255       {
100256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100257       };
100258     } catch (...) {
100259       {
100260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100261       };
100262     }
100263   }
100264
100265   jresult = result;
100266   return jresult;
100267 }
100268
100269
100270 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetTotalPages(void * jarg1) {
100271   unsigned int jresult ;
100272   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100273   unsigned int result;
100274
100275   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100276   {
100277     try {
100278       result = (unsigned int)(*arg1)->GetTotalPages();
100279     } catch (std::out_of_range& e) {
100280       {
100281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100282       };
100283     } catch (std::exception& e) {
100284       {
100285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100286       };
100287     } catch (Dali::DaliException e) {
100288       {
100289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100290       };
100291     } catch (...) {
100292       {
100293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100294       };
100295     }
100296   }
100297
100298   jresult = result;
100299   return jresult;
100300 }
100301
100302
100303 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_GetType(void * jarg1) {
100304   int jresult ;
100305   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100306   Dali::Toolkit::Ruler::RulerType result;
100307
100308   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100309   {
100310     try {
100311       result = (Dali::Toolkit::Ruler::RulerType)(*arg1)->GetType();
100312     } catch (std::out_of_range& e) {
100313       {
100314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100315       };
100316     } catch (std::exception& e) {
100317       {
100318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100319       };
100320     } catch (Dali::DaliException e) {
100321       {
100322         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100323       };
100324     } catch (...) {
100325       {
100326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100327       };
100328     }
100329   }
100330
100331   jresult = (int)result;
100332   return jresult;
100333 }
100334
100335
100336 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_IsEnabled(void * jarg1) {
100337   unsigned int jresult ;
100338   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100339   bool result;
100340
100341   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100342   {
100343     try {
100344       result = (bool)(*arg1)->IsEnabled();
100345     } catch (std::out_of_range& e) {
100346       {
100347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100348       };
100349     } catch (std::exception& e) {
100350       {
100351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100352       };
100353     } catch (Dali::DaliException e) {
100354       {
100355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100356       };
100357     } catch (...) {
100358       {
100359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100360       };
100361     }
100362   }
100363
100364   jresult = result;
100365   return jresult;
100366 }
100367
100368
100369 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Enable(void * jarg1) {
100370   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100371
100372   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100373   {
100374     try {
100375       (*arg1)->Enable();
100376     } catch (std::out_of_range& e) {
100377       {
100378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100379       };
100380     } catch (std::exception& e) {
100381       {
100382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100383       };
100384     } catch (Dali::DaliException e) {
100385       {
100386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100387       };
100388     } catch (...) {
100389       {
100390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100391       };
100392     }
100393   }
100394
100395 }
100396
100397
100398 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Disable(void * jarg1) {
100399   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100400
100401   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100402   {
100403     try {
100404       (*arg1)->Disable();
100405     } catch (std::out_of_range& e) {
100406       {
100407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100408       };
100409     } catch (std::exception& e) {
100410       {
100411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100412       };
100413     } catch (Dali::DaliException e) {
100414       {
100415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100416       };
100417     } catch (...) {
100418       {
100419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100420       };
100421     }
100422   }
100423
100424 }
100425
100426
100427 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_SetDomain(void * jarg1, void * jarg2) {
100428   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100429   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
100430   Dali::Toolkit::RulerDomain *argp2 ;
100431
100432   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100433   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
100434   if (!argp2) {
100435     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
100436     return ;
100437   }
100438   arg2 = *argp2;
100439   {
100440     try {
100441       (*arg1)->SetDomain(arg2);
100442     } catch (std::out_of_range& e) {
100443       {
100444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100445       };
100446     } catch (std::exception& e) {
100447       {
100448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100449       };
100450     } catch (Dali::DaliException e) {
100451       {
100452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100453       };
100454     } catch (...) {
100455       {
100456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100457       };
100458     }
100459   }
100460
100461 }
100462
100463
100464 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_GetDomain(void * jarg1) {
100465   void * jresult ;
100466   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100467   Dali::Toolkit::RulerDomain *result = 0 ;
100468
100469   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100470   {
100471     try {
100472       result = (Dali::Toolkit::RulerDomain *) &(*arg1)->GetDomain();
100473     } catch (std::out_of_range& e) {
100474       {
100475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100476       };
100477     } catch (std::exception& e) {
100478       {
100479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100480       };
100481     } catch (Dali::DaliException e) {
100482       {
100483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100484       };
100485     } catch (...) {
100486       {
100487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100488       };
100489     }
100490   }
100491
100492   jresult = (void *)result;
100493   return jresult;
100494 }
100495
100496
100497 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_DisableDomain(void * jarg1) {
100498   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100499
100500   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100501   {
100502     try {
100503       (*arg1)->DisableDomain();
100504     } catch (std::out_of_range& e) {
100505       {
100506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100507       };
100508     } catch (std::exception& e) {
100509       {
100510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100511       };
100512     } catch (Dali::DaliException e) {
100513       {
100514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100515       };
100516     } catch (...) {
100517       {
100518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100519       };
100520     }
100521   }
100522
100523 }
100524
100525
100526 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
100527   float jresult ;
100528   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100529   float arg2 ;
100530   float arg3 ;
100531   float arg4 ;
100532   float result;
100533
100534   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100535   arg2 = (float)jarg2;
100536   arg3 = (float)jarg3;
100537   arg4 = (float)jarg4;
100538   {
100539     try {
100540       result = (float)(*arg1)->Clamp(arg2,arg3,arg4);
100541     } catch (std::out_of_range& e) {
100542       {
100543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100544       };
100545     } catch (std::exception& e) {
100546       {
100547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100548       };
100549     } catch (Dali::DaliException e) {
100550       {
100551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100552       };
100553     } catch (...) {
100554       {
100555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100556       };
100557     }
100558   }
100559
100560   jresult = result;
100561   return jresult;
100562 }
100563
100564
100565 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
100566   float jresult ;
100567   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100568   float arg2 ;
100569   float arg3 ;
100570   float result;
100571
100572   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100573   arg2 = (float)jarg2;
100574   arg3 = (float)jarg3;
100575   {
100576     try {
100577       result = (float)(*arg1)->Clamp(arg2,arg3);
100578     } catch (std::out_of_range& e) {
100579       {
100580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100581       };
100582     } catch (std::exception& e) {
100583       {
100584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100585       };
100586     } catch (Dali::DaliException e) {
100587       {
100588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100589       };
100590     } catch (...) {
100591       {
100592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100593       };
100594     }
100595   }
100596
100597   jresult = result;
100598   return jresult;
100599 }
100600
100601
100602 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_2(void * jarg1, float jarg2) {
100603   float jresult ;
100604   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100605   float arg2 ;
100606   float result;
100607
100608   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100609   arg2 = (float)jarg2;
100610   {
100611     try {
100612       result = (float)(*arg1)->Clamp(arg2);
100613     } catch (std::out_of_range& e) {
100614       {
100615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100616       };
100617     } catch (std::exception& e) {
100618       {
100619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100620       };
100621     } catch (Dali::DaliException e) {
100622       {
100623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100624       };
100625     } catch (...) {
100626       {
100627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100628       };
100629     }
100630   }
100631
100632   jresult = result;
100633   return jresult;
100634 }
100635
100636
100637 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
100638   float jresult ;
100639   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100640   float arg2 ;
100641   float arg3 ;
100642   float arg4 ;
100643   Dali::Toolkit::ClampState *arg5 = 0 ;
100644   float result;
100645
100646   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100647   arg2 = (float)jarg2;
100648   arg3 = (float)jarg3;
100649   arg4 = (float)jarg4;
100650   arg5 = (Dali::Toolkit::ClampState *)jarg5;
100651   if (!arg5) {
100652     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
100653     return 0;
100654   }
100655   {
100656     try {
100657       result = (float)(*arg1)->Clamp(arg2,arg3,arg4,*arg5);
100658     } catch (std::out_of_range& e) {
100659       {
100660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100661       };
100662     } catch (std::exception& e) {
100663       {
100664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100665       };
100666     } catch (Dali::DaliException e) {
100667       {
100668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100669       };
100670     } catch (...) {
100671       {
100672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100673       };
100674     }
100675   }
100676
100677   jresult = result;
100678   return jresult;
100679 }
100680
100681
100682 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
100683   float jresult ;
100684   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100685   float arg2 ;
100686   float arg3 ;
100687   float arg4 ;
100688   float arg5 ;
100689   float result;
100690
100691   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100692   arg2 = (float)jarg2;
100693   arg3 = (float)jarg3;
100694   arg4 = (float)jarg4;
100695   arg5 = (float)jarg5;
100696   {
100697     try {
100698       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
100699     } catch (std::out_of_range& e) {
100700       {
100701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100702       };
100703     } catch (std::exception& e) {
100704       {
100705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100706       };
100707     } catch (Dali::DaliException e) {
100708       {
100709         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100710       };
100711     } catch (...) {
100712       {
100713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100714       };
100715     }
100716   }
100717
100718   jresult = result;
100719   return jresult;
100720 }
100721
100722
100723 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
100724   float jresult ;
100725   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100726   float arg2 ;
100727   float arg3 ;
100728   float arg4 ;
100729   float result;
100730
100731   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100732   arg2 = (float)jarg2;
100733   arg3 = (float)jarg3;
100734   arg4 = (float)jarg4;
100735   {
100736     try {
100737       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4);
100738     } catch (std::out_of_range& e) {
100739       {
100740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100741       };
100742     } catch (std::exception& e) {
100743       {
100744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100745       };
100746     } catch (Dali::DaliException e) {
100747       {
100748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100749       };
100750     } catch (...) {
100751       {
100752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100753       };
100754     }
100755   }
100756
100757   jresult = result;
100758   return jresult;
100759 }
100760
100761
100762 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
100763   float jresult ;
100764   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100765   float arg2 ;
100766   float arg3 ;
100767   float result;
100768
100769   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100770   arg2 = (float)jarg2;
100771   arg3 = (float)jarg3;
100772   {
100773     try {
100774       result = (float)(*arg1)->SnapAndClamp(arg2,arg3);
100775     } catch (std::out_of_range& e) {
100776       {
100777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100778       };
100779     } catch (std::exception& e) {
100780       {
100781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100782       };
100783     } catch (Dali::DaliException e) {
100784       {
100785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100786       };
100787     } catch (...) {
100788       {
100789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100790       };
100791     }
100792   }
100793
100794   jresult = result;
100795   return jresult;
100796 }
100797
100798
100799 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
100800   float jresult ;
100801   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100802   float arg2 ;
100803   float result;
100804
100805   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100806   arg2 = (float)jarg2;
100807   {
100808     try {
100809       result = (float)(*arg1)->SnapAndClamp(arg2);
100810     } catch (std::out_of_range& e) {
100811       {
100812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100813       };
100814     } catch (std::exception& e) {
100815       {
100816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100817       };
100818     } catch (Dali::DaliException e) {
100819       {
100820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100821       };
100822     } catch (...) {
100823       {
100824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100825       };
100826     }
100827   }
100828
100829   jresult = result;
100830   return jresult;
100831 }
100832
100833
100834 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
100835   float jresult ;
100836   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100837   float arg2 ;
100838   float arg3 ;
100839   float arg4 ;
100840   float arg5 ;
100841   Dali::Toolkit::ClampState *arg6 = 0 ;
100842   float result;
100843
100844   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100845   arg2 = (float)jarg2;
100846   arg3 = (float)jarg3;
100847   arg4 = (float)jarg4;
100848   arg5 = (float)jarg5;
100849   arg6 = (Dali::Toolkit::ClampState *)jarg6;
100850   if (!arg6) {
100851     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
100852     return 0;
100853   }
100854   {
100855     try {
100856       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
100857     } catch (std::out_of_range& e) {
100858       {
100859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100860       };
100861     } catch (std::exception& e) {
100862       {
100863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100864       };
100865     } catch (Dali::DaliException e) {
100866       {
100867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100868       };
100869     } catch (...) {
100870       {
100871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100872       };
100873     }
100874   }
100875
100876   jresult = result;
100877   return jresult;
100878 }
100879
100880
100881 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reference(void * jarg1) {
100882   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100883
100884   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100885   {
100886     try {
100887       (*arg1)->Reference();
100888     } catch (std::out_of_range& e) {
100889       {
100890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100891       };
100892     } catch (std::exception& e) {
100893       {
100894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100895       };
100896     } catch (Dali::DaliException e) {
100897       {
100898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100899       };
100900     } catch (...) {
100901       {
100902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100903       };
100904     }
100905   }
100906
100907 }
100908
100909
100910 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Unreference(void * jarg1) {
100911   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100912
100913   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100914   {
100915     try {
100916       (*arg1)->Unreference();
100917     } catch (std::out_of_range& e) {
100918       {
100919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100920       };
100921     } catch (std::exception& e) {
100922       {
100923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100924       };
100925     } catch (Dali::DaliException e) {
100926       {
100927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100928       };
100929     } catch (...) {
100930       {
100931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100932       };
100933     }
100934   }
100935
100936 }
100937
100938
100939 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_ReferenceCount(void * jarg1) {
100940   int jresult ;
100941   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100942   int result;
100943
100944   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100945   {
100946     try {
100947       result = (int)(*arg1)->ReferenceCount();
100948     } catch (std::out_of_range& e) {
100949       {
100950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100951       };
100952     } catch (std::exception& e) {
100953       {
100954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100955       };
100956     } catch (Dali::DaliException e) {
100957       {
100958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100959       };
100960     } catch (...) {
100961       {
100962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100963       };
100964     }
100965   }
100966
100967   jresult = result;
100968   return jresult;
100969 }
100970
100971
100972 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Empty(void * jarg1) {
100973   unsigned int jresult ;
100974   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100975   bool result;
100976
100977   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100978   {
100979     try {
100980       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
100981     } catch (std::out_of_range& e) {
100982       {
100983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100984       };
100985     } catch (std::exception& e) {
100986       {
100987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100988       };
100989     } catch (Dali::DaliException e) {
100990       {
100991         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100992       };
100993     } catch (...) {
100994       {
100995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100996       };
100997     }
100998   }
100999
101000   jresult = result;
101001   return jresult;
101002 }
101003
101004
101005 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_GetConnectionCount(void * jarg1) {
101006   unsigned long jresult ;
101007   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
101008   std::size_t result;
101009
101010   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
101011   {
101012     try {
101013       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
101014     } catch (std::out_of_range& e) {
101015       {
101016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101017       };
101018     } catch (std::exception& e) {
101019       {
101020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101021       };
101022     } catch (Dali::DaliException e) {
101023       {
101024         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
101025       };
101026     } catch (...) {
101027       {
101028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101029       };
101030     }
101031   }
101032
101033   jresult = (unsigned long)result;
101034   return jresult;
101035 }
101036
101037
101038 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Connect(void * jarg1, void * jarg2) {
101039   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
101040   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
101041
101042   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
101043   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
101044   {
101045     try {
101046       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
101047     } catch (std::out_of_range& e) {
101048       {
101049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101050       };
101051     } catch (std::exception& e) {
101052       {
101053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101054       };
101055     } catch (Dali::DaliException e) {
101056       {
101057         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
101058       };
101059     } catch (...) {
101060       {
101061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101062       };
101063     }
101064   }
101065
101066 }
101067
101068
101069 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Disconnect(void * jarg1, void * jarg2) {
101070   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
101071   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
101072
101073   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
101074   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
101075   {
101076     try {
101077       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
101078     } catch (std::out_of_range& e) {
101079       {
101080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101081       };
101082     } catch (std::exception& e) {
101083       {
101084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101085       };
101086     } catch (Dali::DaliException e) {
101087       {
101088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
101089       };
101090     } catch (...) {
101091       {
101092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101093       };
101094     }
101095   }
101096
101097 }
101098
101099
101100 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Emit(void * jarg1, void * jarg2) {
101101   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
101102   Dali::Toolkit::Control arg2 ;
101103   Dali::Toolkit::Control *argp2 ;
101104
101105   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
101106   argp2 = (Dali::Toolkit::Control *)jarg2;
101107   if (!argp2) {
101108     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
101109     return ;
101110   }
101111   arg2 = *argp2;
101112   {
101113     try {
101114       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
101115     } catch (std::out_of_range& e) {
101116       {
101117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101118       };
101119     } catch (std::exception& e) {
101120       {
101121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101122       };
101123     } catch (Dali::DaliException e) {
101124       {
101125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
101126       };
101127     } catch (...) {
101128       {
101129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101130       };
101131     }
101132   }
101133
101134 }
101135
101136
101137 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewResourceReadySignal() {
101138   void * jresult ;
101139   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
101140
101141   {
101142     try {
101143       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
101144     } catch (std::out_of_range& e) {
101145       {
101146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101147       };
101148     } catch (std::exception& e) {
101149       {
101150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101151       };
101152     } catch (Dali::DaliException e) {
101153       {
101154         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
101155       };
101156     } catch (...) {
101157       {
101158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101159       };
101160     }
101161   }
101162
101163   jresult = (void *)result;
101164   return jresult;
101165 }
101166
101167
101168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewResourceReadySignal(void * jarg1) {
101169   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
101170
101171   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
101172   {
101173     try {
101174       delete arg1;
101175     } catch (std::out_of_range& e) {
101176       {
101177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101178       };
101179     } catch (std::exception& e) {
101180       {
101181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101182       };
101183     } catch (Dali::DaliException e) {
101184       {
101185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
101186       };
101187     } catch (...) {
101188       {
101189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101190       };
101191     }
101192   }
101193
101194 }
101195
101196 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_GetRefObjectPtr(Dali::BaseHandle *arg1) {
101197   Dali::RefObject *result = NULL;
101198
101199   if (arg1)
101200   {
101201     result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
101202   }
101203   return result;
101204 }
101205
101206 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_BaseObject_SWIGUpcast(Dali::BaseObject *jarg1) {
101207     return (Dali::RefObject *)jarg1;
101208 }
101209
101210 SWIGEXPORT Dali::SignalObserver * SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SWIGUpcast(Dali::ConnectionTrackerInterface *jarg1) {
101211     return (Dali::SignalObserver *)jarg1;
101212 }
101213
101214 SWIGEXPORT Dali::ConnectionTrackerInterface * SWIGSTDCALL CSharp_Dali_ConnectionTracker_SWIGUpcast(Dali::ConnectionTracker *jarg1) {
101215     return (Dali::ConnectionTrackerInterface *)jarg1;
101216 }
101217
101218 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ObjectRegistry_SWIGUpcast(Dali::ObjectRegistry *jarg1) {
101219     return (Dali::BaseHandle *)jarg1;
101220 }
101221
101222 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyCondition_SWIGUpcast(Dali::PropertyCondition *jarg1) {
101223     return (Dali::BaseHandle *)jarg1;
101224 }
101225
101226 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyNotification_SWIGUpcast(Dali::PropertyNotification *jarg1) {
101227     return (Dali::BaseHandle *)jarg1;
101228 }
101229
101230 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Handle_SWIGUpcast(Dali::Handle *jarg1) {
101231     return (Dali::BaseHandle *)jarg1;
101232 }
101233
101234 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeInfo_SWIGUpcast(Dali::TypeInfo *jarg1) {
101235     return (Dali::BaseHandle *)jarg1;
101236 }
101237
101238 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeRegistry_SWIGUpcast(Dali::TypeRegistry *jarg1) {
101239     return (Dali::BaseHandle *)jarg1;
101240 }
101241
101242 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Image_SWIGUpcast(Dali::Image *jarg1) {
101243     return (Dali::BaseHandle *)jarg1;
101244 }
101245
101246 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelData_SWIGUpcast(Dali::PixelData *jarg1) {
101247     return (Dali::BaseHandle *)jarg1;
101248 }
101249
101250 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Texture_SWIGUpcast(Dali::Texture *jarg1) {
101251     return (Dali::BaseHandle *)jarg1;
101252 }
101253
101254 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Sampler_SWIGUpcast(Dali::Sampler *jarg1) {
101255     return (Dali::BaseHandle *)jarg1;
101256 }
101257
101258 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TextureSet_SWIGUpcast(Dali::TextureSet *jarg1) {
101259     return (Dali::BaseHandle *)jarg1;
101260 }
101261
101262 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyBuffer_SWIGUpcast(Dali::PropertyBuffer *jarg1) {
101263     return (Dali::BaseHandle *)jarg1;
101264 }
101265
101266 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Geometry_SWIGUpcast(Dali::Geometry *jarg1) {
101267     return (Dali::BaseHandle *)jarg1;
101268 }
101269
101270 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Shader_SWIGUpcast(Dali::Shader *jarg1) {
101271     return (Dali::Handle *)jarg1;
101272 }
101273
101274 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Renderer_SWIGUpcast(Dali::Renderer *jarg1) {
101275     return (Dali::Handle *)jarg1;
101276 }
101277
101278 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_FrameBuffer_SWIGUpcast(Dali::FrameBuffer *jarg1) {
101279     return (Dali::BaseHandle *)jarg1;
101280 }
101281
101282 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_RenderTaskList_SWIGUpcast(Dali::RenderTaskList *jarg1) {
101283     return (Dali::BaseHandle *)jarg1;
101284 }
101285
101286 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_RenderTask_SWIGUpcast(Dali::RenderTask *jarg1) {
101287     return (Dali::Handle *)jarg1;
101288 }
101289
101290 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Touch_SWIGUpcast(Dali::TouchData *jarg1) {
101291     return (Dali::BaseHandle *)jarg1;
101292 }
101293
101294 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_GestureDetector_SWIGUpcast(Dali::GestureDetector *jarg1) {
101295     return (Dali::Handle *)jarg1;
101296 }
101297
101298 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SWIGUpcast(Dali::LongPressGestureDetector *jarg1) {
101299     return (Dali::GestureDetector *)jarg1;
101300 }
101301
101302 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_LongPressGesture_SWIGUpcast(Dali::LongPressGesture *jarg1) {
101303     return (Dali::Gesture *)jarg1;
101304 }
101305
101306 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Actor_SWIGUpcast(Dali::Actor *jarg1) {
101307     return (Dali::Handle *)jarg1;
101308 }
101309
101310 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_Layer_SWIGUpcast(Dali::Layer *jarg1) {
101311     return (Dali::Actor *)jarg1;
101312 }
101313
101314 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Stage_SWIGUpcast(Dali::Stage *jarg1) {
101315     return (Dali::BaseHandle *)jarg1;
101316 }
101317
101318 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_CustomActorImpl_SWIGUpcast(Dali::CustomActorImpl *jarg1) {
101319     return (Dali::RefObject *)jarg1;
101320 }
101321
101322 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CustomActor_SWIGUpcast(Dali::CustomActor *jarg1) {
101323     return (Dali::Actor *)jarg1;
101324 }
101325
101326 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PanGestureDetector_SWIGUpcast(Dali::PanGestureDetector *jarg1) {
101327     return (Dali::GestureDetector *)jarg1;
101328 }
101329
101330 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PanGesture_SWIGUpcast(Dali::PanGesture *jarg1) {
101331     return (Dali::Gesture *)jarg1;
101332 }
101333
101334 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_SWIGUpcast(Dali::PinchGestureDetector *jarg1) {
101335     return (Dali::GestureDetector *)jarg1;
101336 }
101337
101338 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PinchGesture_SWIGUpcast(Dali::PinchGesture *jarg1) {
101339     return (Dali::Gesture *)jarg1;
101340 }
101341
101342 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_TapGestureDetector_SWIGUpcast(Dali::TapGestureDetector *jarg1) {
101343     return (Dali::GestureDetector *)jarg1;
101344 }
101345
101346 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_TapGesture_SWIGUpcast(Dali::TapGesture *jarg1) {
101347     return (Dali::Gesture *)jarg1;
101348 }
101349
101350 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyFrames_SWIGUpcast(Dali::KeyFrames *jarg1) {
101351     return (Dali::BaseHandle *)jarg1;
101352 }
101353
101354 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Path_SWIGUpcast(Dali::Path *jarg1) {
101355     return (Dali::Handle *)jarg1;
101356 }
101357
101358 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_LinearConstrainer_SWIGUpcast(Dali::LinearConstrainer *jarg1) {
101359     return (Dali::Handle *)jarg1;
101360 }
101361
101362 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_PathConstrainer_SWIGUpcast(Dali::PathConstrainer *jarg1) {
101363     return (Dali::Handle *)jarg1;
101364 }
101365
101366 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_BufferImage_SWIGUpcast(Dali::BufferImage *jarg1) {
101367     return (Dali::Image *)jarg1;
101368 }
101369
101370 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_SWIGUpcast(Dali::EncodedBufferImage *jarg1) {
101371     return (Dali::Image *)jarg1;
101372 }
101373
101374 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_NativeImage_SWIGUpcast(Dali::NativeImage *jarg1) {
101375     return (Dali::Image *)jarg1;
101376 }
101377
101378 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_NativeImageInterface_SWIGUpcast(Dali::NativeImageInterface *jarg1) {
101379     return (Dali::RefObject *)jarg1;
101380 }
101381
101382 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_ResourceImage_SWIGUpcast(Dali::ResourceImage *jarg1) {
101383     return (Dali::Image *)jarg1;
101384 }
101385
101386 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_FrameBufferImage_SWIGUpcast(Dali::FrameBufferImage *jarg1) {
101387     return (Dali::Image *)jarg1;
101388 }
101389
101390 SWIGEXPORT Dali::ResourceImage * SWIGSTDCALL CSharp_Dali_NinePatchImage_SWIGUpcast(Dali::NinePatchImage *jarg1) {
101391     return (Dali::ResourceImage *)jarg1;
101392 }
101393
101394 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CameraActor_SWIGUpcast(Dali::CameraActor *jarg1) {
101395     return (Dali::Actor *)jarg1;
101396 }
101397
101398 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Timer_SWIGUpcast(Dali::Timer *jarg1) {
101399     return (Dali::BaseHandle *)jarg1;
101400 }
101401
101402 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_SWIGUpcast(Dali::DragAndDropDetector *jarg1) {
101403     return (Dali::BaseHandle *)jarg1;
101404 }
101405
101406
101407 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Builder_SWIGUpcast(Dali::Toolkit::Builder *jarg1) {
101408     return (Dali::BaseHandle *)jarg1;
101409 }
101410
101411 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TransitionData_SWIGUpcast(Dali::Toolkit::TransitionData *jarg1) {
101412     return (Dali::BaseHandle *)jarg1;
101413 }
101414
101415 SWIGEXPORT Dali::CustomActorImpl * SWIGSTDCALL CSharp_Dali_ViewImpl_SWIGUpcast(Dali::Toolkit::Internal::Control *jarg1) {
101416     return (Dali::CustomActorImpl *)jarg1;
101417 }
101418
101419 SWIGEXPORT Dali::CustomActor * SWIGSTDCALL CSharp_Dali_View_SWIGUpcast(Dali::Toolkit::Control *jarg1) {
101420     return (Dali::CustomActor *)jarg1;
101421 }
101422
101423 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SWIGUpcast(Dali::Toolkit::KeyInputFocusManager *jarg1) {
101424     return (Dali::BaseHandle *)jarg1;
101425 }
101426
101427 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Alignment_SWIGUpcast(Dali::Toolkit::Alignment *jarg1) {
101428     return (Dali::Toolkit::Control *)jarg1;
101429 }
101430
101431 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Button_SWIGUpcast(Dali::Toolkit::Button *jarg1) {
101432     return (Dali::Toolkit::Control *)jarg1;
101433 }
101434
101435 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_CheckBoxButton_SWIGUpcast(Dali::Toolkit::CheckBoxButton *jarg1) {
101436     return (Dali::Toolkit::Button *)jarg1;
101437 }
101438
101439 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_PushButton_SWIGUpcast(Dali::Toolkit::PushButton *jarg1) {
101440     return (Dali::Toolkit::Button *)jarg1;
101441 }
101442
101443 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_RadioButton_SWIGUpcast(Dali::Toolkit::RadioButton *jarg1) {
101444     return (Dali::Toolkit::Button *)jarg1;
101445 }
101446
101447 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_FlexContainer_SWIGUpcast(Dali::Toolkit::FlexContainer *jarg1) {
101448     return (Dali::Toolkit::Control *)jarg1;
101449 }
101450
101451 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ImageView_SWIGUpcast(Dali::Toolkit::ImageView *jarg1) {
101452     return (Dali::Toolkit::Control *)jarg1;
101453 }
101454
101455 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Model3dView_SWIGUpcast(Dali::Toolkit::Model3dView *jarg1) {
101456     return (Dali::Toolkit::Control *)jarg1;
101457 }
101458
101459 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ScrollBar_SWIGUpcast(Dali::Toolkit::ScrollBar *jarg1) {
101460     return (Dali::Toolkit::Control *)jarg1;
101461 }
101462
101463 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Scrollable_SWIGUpcast(Dali::Toolkit::Scrollable *jarg1) {
101464     return (Dali::Toolkit::Control *)jarg1;
101465 }
101466
101467 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_ItemLayout_SWIGUpcast(Dali::Toolkit::ItemLayout *jarg1) {
101468     return (Dali::RefObject *)jarg1;
101469 }
101470
101471 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ItemView_SWIGUpcast(Dali::Toolkit::ItemView *jarg1) {
101472     return (Dali::Toolkit::Scrollable *)jarg1;
101473 }
101474
101475 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ScrollViewEffect_SWIGUpcast(Dali::Toolkit::ScrollViewEffect *jarg1) {
101476     return (Dali::BaseHandle *)jarg1;
101477 }
101478
101479 SWIGEXPORT Dali::Toolkit::ScrollViewEffect * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_SWIGUpcast(Dali::Toolkit::ScrollViewPagePathEffect *jarg1) {
101480     return (Dali::Toolkit::ScrollViewEffect *)jarg1;
101481 }
101482
101483 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_Ruler_SWIGUpcast(Dali::Toolkit::Ruler *jarg1) {
101484     return (Dali::RefObject *)jarg1;
101485 }
101486
101487 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_DefaultRuler_SWIGUpcast(Dali::Toolkit::DefaultRuler *jarg1) {
101488     return (Dali::Toolkit::Ruler *)jarg1;
101489 }
101490
101491 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_FixedRuler_SWIGUpcast(Dali::Toolkit::FixedRuler *jarg1) {
101492     return (Dali::Toolkit::Ruler *)jarg1;
101493 }
101494
101495 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ScrollView_SWIGUpcast(Dali::Toolkit::ScrollView *jarg1) {
101496     return (Dali::Toolkit::Scrollable *)jarg1;
101497 }
101498
101499 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TableView_SWIGUpcast(Dali::Toolkit::TableView *jarg1) {
101500     return (Dali::Toolkit::Control *)jarg1;
101501 }
101502
101503
101504 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextLabel_SWIGUpcast(Dali::Toolkit::TextLabel *jarg1) {
101505     return (Dali::Toolkit::Control *)jarg1;
101506 }
101507
101508 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AccessibilityManager_SWIGUpcast(Dali::Toolkit::AccessibilityManager *jarg1) {
101509     return (Dali::BaseHandle *)jarg1;
101510 }
101511
101512 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_StyleManager_SWIGUpcast(Dali::Toolkit::StyleManager *jarg1) {
101513     return (Dali::BaseHandle *)jarg1;
101514 }
101515
101516 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Slider_SWIGUpcast(Dali::Toolkit::Slider *jarg1) {
101517     return (Dali::Toolkit::Control *)jarg1;
101518 }
101519
101520 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_VideoView_SWIGUpcast(Dali::Toolkit::VideoView *jarg1) {
101521     return (Dali::Toolkit::Control *)jarg1;
101522 }
101523
101524 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Popup_SWIGUpcast(Dali::Toolkit::Popup *jarg1) {
101525     return (Dali::Toolkit::Control *)jarg1;
101526 }
101527
101528 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ProgressBar_SWIGUpcast(Dali::Toolkit::ProgressBar *jarg1) {
101529     return (Dali::Toolkit::Control *)jarg1;
101530 }
101531
101532 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_GaussianBlurView_SWIGUpcast(Dali::Toolkit::GaussianBlurView *jarg1) {
101533     return (Dali::Toolkit::Control *)jarg1;
101534 }
101535
101536 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_PageTurnView_SWIGUpcast(Dali::Toolkit::PageTurnView *jarg1) {
101537     return (Dali::Toolkit::Control *)jarg1;
101538 }
101539
101540 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_SWIGUpcast(Dali::Toolkit::PageTurnLandscapeView *jarg1) {
101541     return (Dali::Toolkit::PageTurnView *)jarg1;
101542 }
101543
101544 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_SWIGUpcast(Dali::Toolkit::PageTurnPortraitView *jarg1) {
101545     return (Dali::Toolkit::PageTurnView *)jarg1;
101546 }
101547
101548 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_ToggleButton_SWIGUpcast(Dali::Toolkit::ToggleButton *jarg1) {
101549     return (Dali::Toolkit::Button *)jarg1;
101550 }
101551
101552 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualBase_SWIGUpcast(Dali::Toolkit::Visual::Base *jarg1) {
101553     return (Dali::BaseHandle *)jarg1;
101554 }
101555
101556 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualFactory_SWIGUpcast(Dali::Toolkit::VisualFactory *jarg1) {
101557     return (Dali::BaseHandle *)jarg1;
101558 }
101559
101560 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_SWIGUpcast(Dali::Toolkit::AsyncImageLoader *jarg1) {
101561     return (Dali::BaseHandle *)jarg1;
101562 }
101563
101564 /*
101565  * Widget binding
101566  */
101567 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Widget_SWIGUpcast(Dali::Widget *jarg1) {
101568     return (Dali::BaseHandle *)jarg1;
101569 }
101570
101571 SWIGEXPORT Dali::BaseObject * SWIGSTDCALL CSharp_Dali_WidgetImpl_SWIGUpcast(Dali::Internal::Adaptor::Widget *jarg1) {
101572     return (Dali::BaseObject *)jarg1;
101573 }
101574
101575 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_0() {
101576   void * jresult ;
101577   Dali::Widget result;
101578
101579   {
101580     try {
101581       result = Dali::Widget::New();
101582     } catch (std::out_of_range& e) {
101583       {
101584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101585       };
101586     } catch (std::exception& e) {
101587       {
101588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101589       };
101590     } catch (...) {
101591       {
101592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101593       };
101594     }
101595   }
101596   jresult = new Dali::Widget((const Dali::Widget &)result);
101597   return jresult;
101598 }
101599
101600
101601 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_1(void * jarg1) {
101602   void * jresult ;
101603   Dali::Internal::Adaptor::Widget *arg1 = 0 ;
101604   Dali::Widget result;
101605
101606   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101607
101608   if (!arg1) {
101609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Internal::Adaptor::Widget & type is null", 0);
101610     return 0;
101611   }
101612   {
101613     try {
101614       jresult = new Dali::Widget(arg1);
101615     } catch (std::out_of_range& e) {
101616       {
101617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101618       };
101619     } catch (std::exception& e) {
101620       {
101621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101622       };
101623     } catch (...) {
101624       {
101625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101626       };
101627     }
101628   }
101629   return jresult;
101630 }
101631
101632
101633 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Widget() {
101634   void * jresult ;
101635   Dali::Widget *result = 0 ;
101636
101637   {
101638     try {
101639       result = (Dali::Widget *)new Dali::Widget();
101640     } catch (std::out_of_range& e) {
101641       {
101642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101643       };
101644     } catch (std::exception& e) {
101645       {
101646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101647       };
101648     } catch (...) {
101649       {
101650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101651       };
101652     }
101653   }
101654   jresult = (void *)result;
101655   return jresult;
101656 }
101657
101658
101659 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_Assign(void * jarg1, void * jarg2) {
101660   void * jresult ;
101661   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
101662   Dali::Widget *arg2 = 0 ;
101663   Dali::Widget *result = 0 ;
101664
101665   arg1 = (Dali::Widget *)jarg1;
101666   arg2 = (Dali::Widget *)jarg2;
101667   if (!arg2) {
101668     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget const & type is null", 0);
101669     return 0;
101670   }
101671   {
101672     try {
101673       result = (Dali::Widget *) &(arg1)->operator =((Dali::Widget const &)*arg2);
101674     } catch (std::out_of_range& e) {
101675       {
101676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101677       };
101678     } catch (std::exception& e) {
101679       {
101680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101681       };
101682     } catch (...) {
101683       {
101684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101685       };
101686     }
101687   }
101688   jresult = (void *)result;
101689   return jresult;
101690 }
101691
101692
101693 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Widget(void * jarg1) {
101694   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
101695
101696   arg1 = (Dali::Widget *)jarg1;
101697   {
101698     try {
101699       delete arg1;
101700     } catch (std::out_of_range& e) {
101701       {
101702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101703       };
101704     } catch (std::exception& e) {
101705       {
101706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101707       };
101708     } catch (...) {
101709       {
101710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101711       };
101712     }
101713   }
101714 }
101715
101716
101717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetImpl_New() {
101718   void * jresult ;
101719   SwigDirector_WidgetImpl* result;
101720   {
101721     try {
101722       result = new SwigDirector_WidgetImpl();
101723     } catch (std::out_of_range& e) {
101724       {
101725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101726       };
101727     } catch (std::exception& e) {
101728       {
101729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101730       };
101731     } catch (...) {
101732       {
101733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101734       };
101735     }
101736   }
101737   jresult = result;
101738   return jresult;
101739 }
101740
101741
101742 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreate(void * jarg1, char * jarg2, void * jarg3) {
101743   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101744   std::string *arg2 = 0 ;
101745   Dali::Window arg3 ;
101746   Dali::Window *argp3 ;
101747
101748   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101749   if (!jarg2) {
101750     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101751     return ;
101752   }
101753   std::string arg2_str(jarg2);
101754   arg2 = &arg2_str;
101755   argp3 = (Dali::Window *)jarg3;
101756   if (!argp3) {
101757     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
101758     return ;
101759   }
101760   arg3 = *argp3;
101761   {
101762     try {
101763       (arg1)->OnCreate((std::string const &)*arg2,arg3);
101764     } catch (std::out_of_range& e) {
101765       {
101766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101767       };
101768     } catch (std::exception& e) {
101769       {
101770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101771       };
101772     } catch (...) {
101773       {
101774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101775       };
101776     }
101777   }
101778 }
101779
101780 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, void * jarg3) {
101781   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101782   std::string *arg2 = 0 ;
101783   Dali::Window arg3 ;
101784   Dali::Window *argp3 ;
101785
101786   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101787   if (!jarg2) {
101788     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101789     return ;
101790   }
101791   std::string arg2_str(jarg2);
101792   arg2 = &arg2_str;
101793   argp3 = (Dali::Window *)jarg3;
101794   if (!argp3) {
101795     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
101796     return ;
101797   }
101798   arg3 = *argp3;
101799   {
101800     try {
101801       (arg1)->Dali::Internal::Adaptor::Widget::OnCreate((std::string const &)*arg2,arg3);
101802     } catch (std::out_of_range& e) {
101803       {
101804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101805       };
101806     } catch (std::exception& e) {
101807       {
101808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101809       };
101810     } catch (...) {
101811       {
101812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101813       };
101814     }
101815   }
101816 }
101817
101818
101819 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminate(void * jarg1, char * jarg2, int jarg3) {
101820   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101821   std::string *arg2 = 0 ;
101822   Dali::Widget::Termination arg3 ;
101823
101824   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101825   if (!jarg2) {
101826     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101827     return ;
101828   }
101829   std::string arg2_str(jarg2);
101830   arg2 = &arg2_str;
101831   arg3 = (Dali::Widget::Termination)jarg3;
101832   {
101833     try {
101834       (arg1)->OnTerminate((std::string const &)*arg2,arg3);
101835     } catch (std::out_of_range& e) {
101836       {
101837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101838       };
101839     } catch (std::exception& e) {
101840       {
101841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101842       };
101843     } catch (...) {
101844       {
101845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101846       };
101847     }
101848   }
101849 }
101850
101851 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminateSwigExplicitWidgetImpl(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)->Dali::Internal::Adaptor::Widget::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
101884 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPause(void * jarg1) {
101885   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101886
101887   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101888   {
101889     try {
101890       (arg1)->OnPause();
101891     } catch (std::out_of_range& e) {
101892       {
101893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101894       };
101895     } catch (std::exception& e) {
101896       {
101897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101898       };
101899     } catch (...) {
101900       {
101901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101902       };
101903     }
101904   }
101905 }
101906
101907 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPauseSwigExplicitWidgetImpl(void * jarg1) {
101908   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101909
101910   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101911   {
101912     try {
101913       (arg1)->Dali::Internal::Adaptor::Widget::OnPause();
101914     } catch (std::out_of_range& e) {
101915       {
101916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101917       };
101918     } catch (std::exception& e) {
101919       {
101920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101921       };
101922     } catch (...) {
101923       {
101924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101925       };
101926     }
101927   }
101928 }
101929
101930
101931 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResume(void * jarg1) {
101932   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101933
101934   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101935   {
101936     try {
101937       (arg1)->OnResume();
101938     } catch (std::out_of_range& e) {
101939       {
101940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101941       };
101942     } catch (std::exception& e) {
101943       {
101944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101945       };
101946     } catch (...) {
101947       {
101948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101949       };
101950     }
101951   }
101952 }
101953
101954
101955 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResumeSwigExplicitWidgetImpl(void * jarg1) {
101956   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101957
101958   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101959   {
101960     try {
101961       (arg1)->Dali::Internal::Adaptor::Widget::OnResume();
101962     } catch (std::out_of_range& e) {
101963       {
101964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101965       };
101966     } catch (std::exception& e) {
101967       {
101968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101969       };
101970     } catch (...) {
101971       {
101972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101973       };
101974     }
101975   }
101976 }
101977
101978
101979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResize(void * jarg1, void * jarg2) {
101980   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101981   Dali::Window arg2 ;
101982   Dali::Window *argp2 ;
101983
101984   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101985   argp2 = (Dali::Window *)jarg2;
101986   if (!argp2) {
101987     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
101988     return ;
101989   }
101990   arg2 = *argp2;
101991   {
101992     try {
101993       (arg1)->OnResize(arg2);
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 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResizeSwigExplicitWidgetImpl(void * jarg1, void * jarg2) {
102011   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
102012   Dali::Window arg2 ;
102013   Dali::Window *argp2 ;
102014
102015   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
102016   argp2 = (Dali::Window *)jarg2;
102017   if (!argp2) {
102018     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
102019     return ;
102020   }
102021   arg2 = *argp2;
102022   {
102023     try {
102024       (arg1)->Dali::Internal::Adaptor::Widget::OnResize(arg2);
102025     } catch (std::out_of_range& e) {
102026       {
102027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102028       };
102029     } catch (std::exception& e) {
102030       {
102031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102032       };
102033     } catch (...) {
102034       {
102035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102036       };
102037     }
102038   }
102039 }
102040
102041
102042 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdate(void * jarg1, char * jarg2, int jarg3) {
102043   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
102044   std::string *arg2 = 0 ;
102045   int arg3 ;
102046
102047   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
102048   if (!jarg2) {
102049     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102050     return ;
102051   }
102052   std::string arg2_str(jarg2);
102053   arg2 = &arg2_str;
102054   arg3 = (int)jarg3;
102055   {
102056     try {
102057       (arg1)->OnUpdate((std::string const &)*arg2,arg3);
102058     } catch (std::out_of_range& e) {
102059       {
102060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102061       };
102062     } catch (std::exception& e) {
102063       {
102064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102065       };
102066     } catch (...) {
102067       {
102068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102069       };
102070     }
102071   }
102072 }
102073
102074 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdateSwigExplicitWidgetImpl(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)->Dali::Internal::Adaptor::Widget::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
102107 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
102108   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
102109   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
102110   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
102111
102112   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
102113   arg2 = (Dali::SlotObserver *)jarg2;
102114   arg3 = (Dali::CallbackBase *)jarg3;
102115   {
102116     try {
102117       (arg1)->SignalConnected(arg2,arg3);
102118     } catch (std::out_of_range& e) {
102119       {
102120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102121       };
102122     } catch (std::exception& e) {
102123       {
102124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102125       };
102126     } catch (...) {
102127       {
102128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102129       };
102130     }
102131   }
102132 }
102133
102134 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
102135   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
102136   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
102137   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
102138
102139   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
102140   arg2 = (Dali::SlotObserver *)jarg2;
102141   arg3 = (Dali::CallbackBase *)jarg3;
102142   {
102143     try {
102144       (arg1)->Dali::Internal::Adaptor::Widget::SignalConnected(arg2,arg3);
102145     } catch (std::out_of_range& e) {
102146       {
102147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102148       };
102149     } catch (std::exception& e) {
102150       {
102151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102152       };
102153     } catch (...) {
102154       {
102155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102156       };
102157     }
102158   }
102159 }
102160
102161
102162 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
102163   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
102164   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
102165   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
102166
102167   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
102168   arg2 = (Dali::SlotObserver *)jarg2;
102169   arg3 = (Dali::CallbackBase *)jarg3;
102170   {
102171     try {
102172       (arg1)->SignalDisconnected(arg2,arg3);
102173     } catch (std::out_of_range& e) {
102174       {
102175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102176       };
102177     } catch (std::exception& e) {
102178       {
102179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102180       };
102181     } catch (...) {
102182       {
102183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102184       };
102185     }
102186   }
102187 }
102188
102189 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
102190   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
102191   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
102192   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
102193
102194   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
102195   arg2 = (Dali::SlotObserver *)jarg2;
102196   arg3 = (Dali::CallbackBase *)jarg3;
102197   {
102198     try {
102199       (arg1)->Dali::Internal::Adaptor::Widget::SignalDisconnected(arg2,arg3);
102200     } catch (std::out_of_range& e) {
102201       {
102202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102203       };
102204     } catch (std::exception& e) {
102205       {
102206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102207       };
102208     } catch (...) {
102209       {
102210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102211       };
102212     }
102213   }
102214 }
102215
102216 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetContentInfo(void * jarg1, char * jarg2) {
102217   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
102218   std::string *arg2 = 0 ;
102219
102220   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
102221   if (!jarg2) {
102222     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102223     return ;
102224   }
102225   std::string arg2_str(jarg2);
102226   arg2 = &arg2_str;
102227   {
102228     try {
102229       (arg1)->SetContentInfo((std::string const &)*arg2);
102230     } catch (std::out_of_range& e) {
102231       {
102232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102233       };
102234     } catch (std::exception& e) {
102235       {
102236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102237       };
102238     } catch (...) {
102239       {
102240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102241       };
102242     }
102243   }
102244 }
102245
102246
102247 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetImpl(void * jarg1, void * jarg2) {
102248   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
102249   Dali::Internal::Adaptor::Widget::Impl *arg2 = (Dali::Internal::Adaptor::Widget::Impl *) 0 ;
102250
102251   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
102252   arg2 = (Dali::Internal::Adaptor::Widget::Impl *)jarg2;
102253   {
102254     try {
102255       (arg1)->SetImpl(arg2);
102256     } catch (std::out_of_range& e) {
102257       {
102258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102259       };
102260     } catch (std::exception& e) {
102261       {
102262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102263       };
102264     } catch (...) {
102265       {
102266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102267       };
102268     }
102269   }
102270 }
102271
102272 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) {
102273
102274   SwigDirector_WidgetImpl *director = static_cast<SwigDirector_WidgetImpl *>(objarg);
102275   if (director) {
102276     director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5, callback6, callback7);
102277   }
102278 }
102279
102280 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_GetImplementation__SWIG_0(void * jarg1) {
102281   void * jresult ;
102282   Dali::Widget *arg1 = 0 ;
102283   SwigDirector_WidgetImpl *result = 0 ;
102284
102285   arg1 = (Dali::Widget *)jarg1;
102286   if (!arg1) {
102287     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget & type is null", 0);
102288     return 0;
102289   }
102290   {
102291     try {
102292       result = (SwigDirector_WidgetImpl *) &Dali::Internal::Adaptor::GetImplementation(*arg1);
102293     } catch (std::out_of_range& e) {
102294       {
102295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102296       };
102297     } catch (std::exception& e) {
102298       {
102299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102300       };
102301     } catch (...) {
102302       {
102303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102304       };
102305     }
102306   }
102307
102308   jresult = (void *)result;
102309   return jresult;
102310 }
102311
102312
102313 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_New(int jarg1, char * jarg2, char * jarg3) {
102314   void * jresult ;
102315   int *arg1 = (int *) 0 ;
102316   char ***arg2 ;
102317   std::string *arg3 = 0 ;
102318   Dali::WidgetApplication result;
102319   {
102320     int index = 0;
102321     int length = 0;
102322     char *retPtr;
102323     char *nextPtr;
102324     argWidgetC = jarg1;
102325     argWidgetV = new char*[jarg1 + 1];
102326
102327     retPtr = strtok_r( jarg2, " ", &nextPtr);
102328     if( retPtr )
102329     {
102330       length = strlen(retPtr);
102331     }
102332     argWidgetV[index] = new char[length + 1];
102333     if( retPtr )
102334     {
102335       strncpy(argWidgetV[index], retPtr, length);
102336     }
102337     argWidgetV[index][length] = '\0';
102338     index++;
102339
102340     while (index < jarg1)
102341     {
102342       length = 0;
102343       retPtr = strtok_r(NULL, " ", &nextPtr);
102344       if( retPtr )
102345       {
102346         length = strlen(retPtr);
102347       }
102348       argWidgetV[index] = new char[length + 1];
102349       if( retPtr )
102350       {
102351         strncpy(argWidgetV[index], retPtr, length);
102352       }
102353       argWidgetV[index][length] = '\0';
102354       index++;
102355     }
102356
102357     argWidgetV[jarg1] = NULL;
102358     argWidgetC = jarg1;
102359
102360     arg1 = &argWidgetC;
102361     arg2 = &argWidgetV;
102362   }
102363
102364   if (!jarg3) {
102365     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102366     return 0;
102367   }
102368   std::string arg3_str(jarg3);
102369   arg3 = &arg3_str;
102370   {
102371     try {
102372       result = Dali::WidgetApplication::New(arg1,arg2,(std::string const &)*arg3);
102373     } catch (std::out_of_range& e) {
102374       {
102375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102376       };
102377     } catch (std::exception& e) {
102378       {
102379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102380       };
102381     } catch (...) {
102382       {
102383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102384       };
102385     }
102386   }
102387   jresult = new Dali::WidgetApplication((const Dali::WidgetApplication &)result);
102388
102389   return jresult;
102390 }
102391
102392
102393 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_0() {
102394   void * jresult ;
102395   Dali::WidgetApplication *result = 0 ;
102396
102397   {
102398     try {
102399       result = (Dali::WidgetApplication *)new Dali::WidgetApplication();
102400     } catch (std::out_of_range& e) {
102401       {
102402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102403       };
102404     } catch (std::exception& e) {
102405       {
102406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102407       };
102408     } catch (...) {
102409       {
102410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102411       };
102412     }
102413   }
102414   jresult = (void *)result;
102415   return jresult;
102416 }
102417
102418
102419 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_1(void * jarg1) {
102420   void * jresult ;
102421   Dali::WidgetApplication *arg1 = 0 ;
102422   Dali::WidgetApplication *result = 0 ;
102423
102424   arg1 = (Dali::WidgetApplication *)jarg1;
102425   if (!arg1) {
102426     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
102427     return 0;
102428   }
102429   {
102430     try {
102431       result = (Dali::WidgetApplication *)new Dali::WidgetApplication((Dali::WidgetApplication const &)*arg1);
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_WidgetApplication_Assign(void * jarg1, void * jarg2) {
102452   void * jresult ;
102453   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
102454   Dali::WidgetApplication *arg2 = 0 ;
102455   Dali::WidgetApplication *result = 0 ;
102456
102457   arg1 = (Dali::WidgetApplication *)jarg1;
102458   arg2 = (Dali::WidgetApplication *)jarg2;
102459   if (!arg2) {
102460     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
102461     return 0;
102462   }
102463   {
102464     try {
102465       result = (Dali::WidgetApplication *) &(arg1)->operator =((Dali::WidgetApplication const &)*arg2);
102466     } catch (std::out_of_range& e) {
102467       {
102468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102469       };
102470     } catch (std::exception& e) {
102471       {
102472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102473       };
102474     } catch (...) {
102475       {
102476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102477       };
102478     }
102479   }
102480   jresult = (void *)result;
102481   return jresult;
102482 }
102483
102484
102485 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WidgetApplication(void * jarg1) {
102486   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
102487
102488   arg1 = (Dali::WidgetApplication *)jarg1;
102489   {
102490     try {
102491       delete arg1;
102492       if( argWidgetV )
102493       {
102494         // free string data
102495         for( int i=0; i < argWidgetC+1; i++)
102496         {
102497           delete [] argWidgetV[i];
102498         }
102499         delete [] argWidgetV;
102500       }
102501     } catch (std::out_of_range& e) {
102502       {
102503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102504       };
102505     } catch (std::exception& e) {
102506       {
102507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102508       };
102509     } catch (...) {
102510       {
102511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102512       };
102513     }
102514   }
102515 }
102516
102517
102518 typedef Dali::Widget*(SWIGSTDCALL *CSharpCreateWidgetFunction)(const std::string&);
102519 CSharpCreateWidgetFunction _CSharpCreateWidgetFunction = NULL;
102520
102521 static Dali::Widget SWIGSTDCALL WidgetFactoryFunction( const std::string& widgetName )
102522 {
102523   Widget* widget = _CSharpCreateWidgetFunction( widgetName.c_str() );
102524   return *widget;
102525 }
102526
102527 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetApplication_RegisterWidgetCreatingFunction(void * jarg1, char** jarg2, void * jarg3) {
102528   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
102529   std::string *arg2 = 0 ;
102530
102531   arg1 = (Dali::WidgetApplication *)jarg1;
102532   if (!jarg2) {
102533     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102534     return ;
102535   }
102536   std::string arg2_str(*jarg2);
102537   arg2 = &arg2_str;
102538
102539   if(!_CSharpCreateWidgetFunction)
102540   {
102541     _CSharpCreateWidgetFunction = (Dali::Widget*(*)(const std::string&))jarg3;
102542   }
102543
102544   {
102545     try {
102546       (arg1)->RegisterWidgetCreatingFunction((std::string const &)*arg2, WidgetFactoryFunction);
102547     } catch (std::out_of_range& e) {
102548       {
102549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102550       };
102551     } catch (std::exception& e) {
102552       {
102553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102554       };
102555     } catch (...) {
102556       {
102557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102558       };
102559     }
102560   }
102561
102562   //Typemap argout in c++ file.
102563   //This will convert c++ string to c# string
102564   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
102565 }
102566
102567
102568 //for PixelBuffer and ImageLoading
102569
102570 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelBuffer_SWIGUpcast(Dali::Devel::PixelBuffer *jarg1) {
102571     return (Dali::BaseHandle *)jarg1;
102572 }
102573
102574 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_New(unsigned int jarg1, unsigned int jarg2, int jarg3) {
102575   void * jresult ;
102576   unsigned int arg1 ;
102577   unsigned int arg2 ;
102578   Dali::Pixel::Format arg3 ;
102579   Dali::Devel::PixelBuffer result;
102580
102581   arg1 = (unsigned int)jarg1;
102582   arg2 = (unsigned int)jarg2;
102583   arg3 = (Dali::Pixel::Format)jarg3;
102584   {
102585     try {
102586       result = Dali::Devel::PixelBuffer::New(arg1,arg2,arg3);
102587     } catch (std::out_of_range& e) {
102588       {
102589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102590       };
102591     } catch (std::exception& e) {
102592       {
102593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102594       };
102595     } catch (...) {
102596       {
102597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102598       };
102599     }
102600   }
102601   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102602   return jresult;
102603 }
102604
102605
102606 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_0() {
102607   void * jresult ;
102608   Dali::Devel::PixelBuffer *result = 0 ;
102609
102610   {
102611     try {
102612       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer();
102613     } catch (std::out_of_range& e) {
102614       {
102615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102616       };
102617     } catch (std::exception& e) {
102618       {
102619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102620       };
102621     } catch (...) {
102622       {
102623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102624       };
102625     }
102626   }
102627   jresult = (void *)result;
102628   return jresult;
102629 }
102630
102631
102632 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelBuffer(void * jarg1) {
102633   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102634
102635   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102636   {
102637     try {
102638       delete arg1;
102639     } catch (std::out_of_range& e) {
102640       {
102641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102642       };
102643     } catch (std::exception& e) {
102644       {
102645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102646       };
102647     } catch (...) {
102648       {
102649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102650       };
102651     }
102652   }
102653 }
102654
102655
102656 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_1(void * jarg1) {
102657   void * jresult ;
102658   Dali::Devel::PixelBuffer *arg1 = 0 ;
102659   Dali::Devel::PixelBuffer *result = 0 ;
102660
102661   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102662   if (!arg1) {
102663     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
102664     return 0;
102665   }
102666   {
102667     try {
102668       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer((Dali::Devel::PixelBuffer const &)*arg1);
102669     } catch (std::out_of_range& e) {
102670       {
102671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102672       };
102673     } catch (std::exception& e) {
102674       {
102675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102676       };
102677     } catch (...) {
102678       {
102679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102680       };
102681     }
102682   }
102683   jresult = (void *)result;
102684   return jresult;
102685 }
102686
102687
102688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Assign(void * jarg1, void * jarg2) {
102689   void * jresult ;
102690   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102691   Dali::Devel::PixelBuffer *arg2 = 0 ;
102692   Dali::Devel::PixelBuffer *result = 0 ;
102693
102694   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102695   arg2 = (Dali::Devel::PixelBuffer *)jarg2;
102696   if (!arg2) {
102697     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
102698     return 0;
102699   }
102700   {
102701     try {
102702       result = (Dali::Devel::PixelBuffer *) &(arg1)->operator =((Dali::Devel::PixelBuffer const &)*arg2);
102703     } catch (std::out_of_range& e) {
102704       {
102705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102706       };
102707     } catch (std::exception& e) {
102708       {
102709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102710       };
102711     } catch (...) {
102712       {
102713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102714       };
102715     }
102716   }
102717   jresult = (void *)result;
102718   return jresult;
102719 }
102720
102721
102722 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Convert(void * jarg1) {
102723   void * jresult ;
102724   Dali::Devel::PixelBuffer *arg1 = 0 ;
102725   Dali::PixelData result;
102726
102727   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102728   if (!arg1) {
102729     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer & type is null", 0);
102730     return 0;
102731   }
102732   {
102733     try {
102734       result = Dali::Devel::PixelBuffer::Convert(*arg1);
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 = new Dali::PixelData((const Dali::PixelData &)result);
102750   return jresult;
102751 }
102752
102753
102754 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_CreatePixelData(void * jarg1) {
102755   void * jresult ;
102756   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102757   Dali::PixelData result;
102758
102759   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102760   {
102761     try {
102762       result = ((Dali::Devel::PixelBuffer const *)arg1)->CreatePixelData();
102763     } catch (std::out_of_range& e) {
102764       {
102765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102766       };
102767     } catch (std::exception& e) {
102768       {
102769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102770       };
102771     } catch (...) {
102772       {
102773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102774       };
102775     }
102776   }
102777   jresult = new Dali::PixelData((const Dali::PixelData &)result);
102778   return jresult;
102779 }
102780
102781
102782 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_GetBuffer(void * jarg1) {
102783   void * jresult ;
102784   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102785   unsigned char *result = 0 ;
102786
102787   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102788   {
102789     try {
102790       result = (unsigned char *)(arg1)->GetBuffer();
102791     } catch (std::out_of_range& e) {
102792       {
102793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102794       };
102795     } catch (std::exception& e) {
102796       {
102797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102798       };
102799     } catch (...) {
102800       {
102801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102802       };
102803     }
102804   }
102805   jresult = (void *)result;
102806   return jresult;
102807 }
102808
102809
102810 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetWidth(void * jarg1) {
102811   unsigned int jresult ;
102812   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102813   unsigned int result;
102814
102815   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102816   {
102817     try {
102818       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetWidth();
102819     } catch (std::out_of_range& e) {
102820       {
102821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102822       };
102823     } catch (std::exception& e) {
102824       {
102825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102826       };
102827     } catch (...) {
102828       {
102829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102830       };
102831     }
102832   }
102833   jresult = result;
102834   return jresult;
102835 }
102836
102837
102838 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetHeight(void * jarg1) {
102839   unsigned int jresult ;
102840   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102841   unsigned int result;
102842
102843   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102844   {
102845     try {
102846       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetHeight();
102847     } catch (std::out_of_range& e) {
102848       {
102849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102850       };
102851     } catch (std::exception& e) {
102852       {
102853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102854       };
102855     } catch (...) {
102856       {
102857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102858       };
102859     }
102860   }
102861   jresult = result;
102862   return jresult;
102863 }
102864
102865
102866 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetPixelFormat(void * jarg1) {
102867   int jresult ;
102868   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102869   Dali::Pixel::Format result;
102870
102871   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102872   {
102873     try {
102874       result = (Dali::Pixel::Format)((Dali::Devel::PixelBuffer const *)arg1)->GetPixelFormat();
102875     } catch (std::out_of_range& e) {
102876       {
102877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102878       };
102879     } catch (std::exception& e) {
102880       {
102881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102882       };
102883     } catch (...) {
102884       {
102885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102886       };
102887     }
102888   }
102889   jresult = (int)result;
102890   return jresult;
102891 }
102892
102893
102894 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_0(void * jarg1, void * jarg2, float jarg3, unsigned int jarg4) {
102895   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102896   Dali::Devel::PixelBuffer arg2 ;
102897   float arg3 ;
102898   bool arg4 ;
102899   Dali::Devel::PixelBuffer *argp2 ;
102900
102901   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102902   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
102903   if (!argp2) {
102904     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
102905     return ;
102906   }
102907   arg2 = *argp2;
102908   arg3 = (float)jarg3;
102909   arg4 = jarg4 ? true : false;
102910   {
102911     try {
102912       (arg1)->ApplyMask(arg2,arg3,arg4);
102913     } catch (std::out_of_range& e) {
102914       {
102915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102916       };
102917     } catch (std::exception& e) {
102918       {
102919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102920       };
102921     } catch (...) {
102922       {
102923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102924       };
102925     }
102926   }
102927 }
102928
102929
102930 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
102931   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102932   Dali::Devel::PixelBuffer arg2 ;
102933   float arg3 ;
102934   Dali::Devel::PixelBuffer *argp2 ;
102935
102936   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102937   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
102938   if (!argp2) {
102939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
102940     return ;
102941   }
102942   arg2 = *argp2;
102943   arg3 = (float)jarg3;
102944   {
102945     try {
102946       (arg1)->ApplyMask(arg2,arg3);
102947     } catch (std::out_of_range& e) {
102948       {
102949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102950       };
102951     } catch (std::exception& e) {
102952       {
102953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102954       };
102955     } catch (...) {
102956       {
102957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102958       };
102959     }
102960   }
102961 }
102962
102963
102964 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_2(void * jarg1, void * jarg2) {
102965   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102966   Dali::Devel::PixelBuffer arg2 ;
102967   Dali::Devel::PixelBuffer *argp2 ;
102968
102969   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102970   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
102971   if (!argp2) {
102972     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
102973     return ;
102974   }
102975   arg2 = *argp2;
102976   {
102977     try {
102978       (arg1)->ApplyMask(arg2);
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_ApplyGaussianBlur(void * jarg1, float jarg2) {
102997   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102998   float arg2 ;
102999
103000   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
103001   arg2 = (float)jarg2;
103002   {
103003     try {
103004       (arg1)->ApplyGaussianBlur(arg2);
103005     } catch (std::out_of_range& e) {
103006       {
103007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103008       };
103009     } catch (std::exception& e) {
103010       {
103011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103012       };
103013     } catch (...) {
103014       {
103015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103016       };
103017     }
103018   }
103019 }
103020
103021
103022 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Crop(void * jarg1, unsigned short jarg2, unsigned short jarg3, unsigned short jarg4, unsigned short jarg5) {
103023   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
103024   uint16_t arg2 ;
103025   uint16_t arg3 ;
103026   uint16_t arg4 ;
103027   uint16_t arg5 ;
103028
103029   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
103030   arg2 = (uint16_t)jarg2;
103031   arg3 = (uint16_t)jarg3;
103032   arg4 = (uint16_t)jarg4;
103033   arg5 = (uint16_t)jarg5;
103034   {
103035     try {
103036       (arg1)->Crop(arg2,arg3,arg4,arg5);
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_Resize(void * jarg1, unsigned short jarg2, unsigned short jarg3) {
103055   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
103056   uint16_t arg2 ;
103057   uint16_t arg3 ;
103058
103059   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
103060   arg2 = (uint16_t)jarg2;
103061   arg3 = (uint16_t)jarg3;
103062   {
103063     try {
103064       (arg1)->Resize(arg2,arg3);
103065     } catch (std::out_of_range& e) {
103066       {
103067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103068       };
103069     } catch (std::exception& e) {
103070       {
103071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103072       };
103073     } catch (...) {
103074       {
103075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103076       };
103077     }
103078   }
103079 }
103080
103081
103082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_2(void * jarg1) {
103083   void * jresult ;
103084   Dali::Internal::Adaptor::PixelBuffer *arg1 = (Dali::Internal::Adaptor::PixelBuffer *) 0 ;
103085   Dali::Devel::PixelBuffer *result = 0 ;
103086
103087   arg1 = (Dali::Internal::Adaptor::PixelBuffer *)jarg1;
103088   {
103089     try {
103090       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer(arg1);
103091     } catch (std::out_of_range& e) {
103092       {
103093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103094       };
103095     } catch (std::exception& e) {
103096       {
103097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103098       };
103099     } catch (...) {
103100       {
103101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103102       };
103103     }
103104   }
103105   jresult = (void *)result;
103106   return jresult;
103107 }
103108
103109
103110 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
103111   void * jresult ;
103112   std::string *arg1 = 0 ;
103113   Dali::ImageDimensions arg2 ;
103114   Dali::FittingMode::Type arg3 ;
103115   Dali::SamplingMode::Type arg4 ;
103116   bool arg5 ;
103117   Dali::ImageDimensions *argp2 ;
103118   Dali::Devel::PixelBuffer result;
103119
103120   if (!jarg1) {
103121     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103122     return 0;
103123   }
103124   std::string arg1_str(jarg1);
103125   arg1 = &arg1_str;
103126   argp2 = (Dali::ImageDimensions *)jarg2;
103127   if (!argp2) {
103128     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103129     return 0;
103130   }
103131   arg2 = *argp2;
103132   arg3 = (Dali::FittingMode::Type)jarg3;
103133   arg4 = (Dali::SamplingMode::Type)jarg4;
103134   arg5 = jarg5 ? true : false;
103135   {
103136     try {
103137       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4,arg5);
103138     } catch (std::out_of_range& e) {
103139       {
103140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103141       };
103142     } catch (std::exception& e) {
103143       {
103144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103145       };
103146     } catch (...) {
103147       {
103148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103149       };
103150     }
103151   }
103152   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103153
103154   return jresult;
103155 }
103156
103157
103158 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
103159   void * jresult ;
103160   std::string *arg1 = 0 ;
103161   Dali::ImageDimensions arg2 ;
103162   Dali::FittingMode::Type arg3 ;
103163   Dali::SamplingMode::Type arg4 ;
103164   Dali::ImageDimensions *argp2 ;
103165   Dali::Devel::PixelBuffer result;
103166
103167   if (!jarg1) {
103168     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103169     return 0;
103170   }
103171   std::string arg1_str(jarg1);
103172   arg1 = &arg1_str;
103173   argp2 = (Dali::ImageDimensions *)jarg2;
103174   if (!argp2) {
103175     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103176     return 0;
103177   }
103178   arg2 = *argp2;
103179   arg3 = (Dali::FittingMode::Type)jarg3;
103180   arg4 = (Dali::SamplingMode::Type)jarg4;
103181   {
103182     try {
103183       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4);
103184     } catch (std::out_of_range& e) {
103185       {
103186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103187       };
103188     } catch (std::exception& e) {
103189       {
103190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103191       };
103192     } catch (...) {
103193       {
103194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103195       };
103196     }
103197   }
103198   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103199
103200   return jresult;
103201 }
103202
103203
103204 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
103205   void * jresult ;
103206   std::string *arg1 = 0 ;
103207   Dali::ImageDimensions arg2 ;
103208   Dali::FittingMode::Type arg3 ;
103209   Dali::ImageDimensions *argp2 ;
103210   Dali::Devel::PixelBuffer result;
103211
103212   if (!jarg1) {
103213     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103214     return 0;
103215   }
103216   std::string arg1_str(jarg1);
103217   arg1 = &arg1_str;
103218   argp2 = (Dali::ImageDimensions *)jarg2;
103219   if (!argp2) {
103220     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103221     return 0;
103222   }
103223   arg2 = *argp2;
103224   arg3 = (Dali::FittingMode::Type)jarg3;
103225   {
103226     try {
103227       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3);
103228     } catch (std::out_of_range& e) {
103229       {
103230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103231       };
103232     } catch (std::exception& e) {
103233       {
103234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103235       };
103236     } catch (...) {
103237       {
103238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103239       };
103240     }
103241   }
103242   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103243
103244   return jresult;
103245 }
103246
103247
103248 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_3(char * jarg1, void * jarg2) {
103249   void * jresult ;
103250   std::string *arg1 = 0 ;
103251   Dali::ImageDimensions arg2 ;
103252   Dali::ImageDimensions *argp2 ;
103253   Dali::Devel::PixelBuffer result;
103254
103255   if (!jarg1) {
103256     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103257     return 0;
103258   }
103259   std::string arg1_str(jarg1);
103260   arg1 = &arg1_str;
103261   argp2 = (Dali::ImageDimensions *)jarg2;
103262   if (!argp2) {
103263     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103264     return 0;
103265   }
103266   arg2 = *argp2;
103267   {
103268     try {
103269       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2);
103270     } catch (std::out_of_range& e) {
103271       {
103272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103273       };
103274     } catch (std::exception& e) {
103275       {
103276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103277       };
103278     } catch (...) {
103279       {
103280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103281       };
103282     }
103283   }
103284   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103285
103286   return jresult;
103287 }
103288
103289
103290 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_4(char * jarg1) {
103291   void * jresult ;
103292   std::string *arg1 = 0 ;
103293   Dali::Devel::PixelBuffer result;
103294
103295   if (!jarg1) {
103296     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103297     return 0;
103298   }
103299   std::string arg1_str(jarg1);
103300   arg1 = &arg1_str;
103301   {
103302     try {
103303       result = Dali::LoadImageFromFile((std::string const &)*arg1);
103304     } catch (std::out_of_range& e) {
103305       {
103306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103307       };
103308     } catch (std::exception& e) {
103309       {
103310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103311       };
103312     } catch (...) {
103313       {
103314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103315       };
103316     }
103317   }
103318   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103319
103320   return jresult;
103321 }
103322
103323
103324 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
103325   void * jresult ;
103326   std::string *arg1 = 0 ;
103327   Dali::ImageDimensions arg2 ;
103328   Dali::FittingMode::Type arg3 ;
103329   Dali::SamplingMode::Type arg4 ;
103330   bool arg5 ;
103331   Dali::ImageDimensions *argp2 ;
103332   Dali::ImageDimensions result;
103333
103334   if (!jarg1) {
103335     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103336     return 0;
103337   }
103338   std::string arg1_str(jarg1);
103339   arg1 = &arg1_str;
103340   argp2 = (Dali::ImageDimensions *)jarg2;
103341   if (!argp2) {
103342     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103343     return 0;
103344   }
103345   arg2 = *argp2;
103346   arg3 = (Dali::FittingMode::Type)jarg3;
103347   arg4 = (Dali::SamplingMode::Type)jarg4;
103348   arg5 = jarg5 ? true : false;
103349   {
103350     try {
103351       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4,arg5);
103352     } catch (std::out_of_range& e) {
103353       {
103354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103355       };
103356     } catch (std::exception& e) {
103357       {
103358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103359       };
103360     } catch (...) {
103361       {
103362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103363       };
103364     }
103365   }
103366   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
103367
103368   return jresult;
103369 }
103370
103371
103372 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
103373   void * jresult ;
103374   std::string *arg1 = 0 ;
103375   Dali::ImageDimensions arg2 ;
103376   Dali::FittingMode::Type arg3 ;
103377   Dali::SamplingMode::Type arg4 ;
103378   Dali::ImageDimensions *argp2 ;
103379   Dali::ImageDimensions result;
103380
103381   if (!jarg1) {
103382     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103383     return 0;
103384   }
103385   std::string arg1_str(jarg1);
103386   arg1 = &arg1_str;
103387   argp2 = (Dali::ImageDimensions *)jarg2;
103388   if (!argp2) {
103389     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103390     return 0;
103391   }
103392   arg2 = *argp2;
103393   arg3 = (Dali::FittingMode::Type)jarg3;
103394   arg4 = (Dali::SamplingMode::Type)jarg4;
103395   {
103396     try {
103397       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4);
103398     } catch (std::out_of_range& e) {
103399       {
103400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103401       };
103402     } catch (std::exception& e) {
103403       {
103404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103405       };
103406     } catch (...) {
103407       {
103408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103409       };
103410     }
103411   }
103412   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
103413
103414   return jresult;
103415 }
103416
103417
103418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
103419   void * jresult ;
103420   std::string *arg1 = 0 ;
103421   Dali::ImageDimensions arg2 ;
103422   Dali::FittingMode::Type arg3 ;
103423   Dali::ImageDimensions *argp2 ;
103424   Dali::ImageDimensions result;
103425
103426   if (!jarg1) {
103427     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103428     return 0;
103429   }
103430   std::string arg1_str(jarg1);
103431   arg1 = &arg1_str;
103432   argp2 = (Dali::ImageDimensions *)jarg2;
103433   if (!argp2) {
103434     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103435     return 0;
103436   }
103437   arg2 = *argp2;
103438   arg3 = (Dali::FittingMode::Type)jarg3;
103439   {
103440     try {
103441       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3);
103442     } catch (std::out_of_range& e) {
103443       {
103444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103445       };
103446     } catch (std::exception& e) {
103447       {
103448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103449       };
103450     } catch (...) {
103451       {
103452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103453       };
103454     }
103455   }
103456   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
103457
103458   return jresult;
103459 }
103460
103461
103462 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_3(char * jarg1, void * jarg2) {
103463   void * jresult ;
103464   std::string *arg1 = 0 ;
103465   Dali::ImageDimensions arg2 ;
103466   Dali::ImageDimensions *argp2 ;
103467   Dali::ImageDimensions result;
103468
103469   if (!jarg1) {
103470     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103471     return 0;
103472   }
103473   std::string arg1_str(jarg1);
103474   arg1 = &arg1_str;
103475   argp2 = (Dali::ImageDimensions *)jarg2;
103476   if (!argp2) {
103477     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103478     return 0;
103479   }
103480   arg2 = *argp2;
103481   {
103482     try {
103483       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2);
103484     } catch (std::out_of_range& e) {
103485       {
103486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103487       };
103488     } catch (std::exception& e) {
103489       {
103490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103491       };
103492     } catch (...) {
103493       {
103494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103495       };
103496     }
103497   }
103498   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
103499
103500   return jresult;
103501 }
103502
103503
103504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_4(char * jarg1) {
103505   void * jresult ;
103506   std::string *arg1 = 0 ;
103507   Dali::ImageDimensions result;
103508
103509   if (!jarg1) {
103510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103511     return 0;
103512   }
103513   std::string arg1_str(jarg1);
103514   arg1 = &arg1_str;
103515   {
103516     try {
103517       result = Dali::GetClosestImageSize((std::string const &)*arg1);
103518     } catch (std::out_of_range& e) {
103519       {
103520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103521       };
103522     } catch (std::exception& e) {
103523       {
103524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103525       };
103526     } catch (...) {
103527       {
103528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103529       };
103530     }
103531   }
103532   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
103533
103534   return jresult;
103535 }
103536
103537
103538 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
103539   void * jresult ;
103540   std::string *arg1 = 0 ;
103541   Dali::ImageDimensions arg2 ;
103542   Dali::FittingMode::Type arg3 ;
103543   Dali::SamplingMode::Type arg4 ;
103544   bool arg5 ;
103545   Dali::ImageDimensions *argp2 ;
103546   Dali::Devel::PixelBuffer result;
103547
103548   if (!jarg1) {
103549     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103550     return 0;
103551   }
103552   std::string arg1_str(jarg1);
103553   arg1 = &arg1_str;
103554   argp2 = (Dali::ImageDimensions *)jarg2;
103555   if (!argp2) {
103556     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103557     return 0;
103558   }
103559   arg2 = *argp2;
103560   arg3 = (Dali::FittingMode::Type)jarg3;
103561   arg4 = (Dali::SamplingMode::Type)jarg4;
103562   arg5 = jarg5 ? true : false;
103563   {
103564     try {
103565       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4,arg5);
103566     } catch (std::out_of_range& e) {
103567       {
103568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103569       };
103570     } catch (std::exception& e) {
103571       {
103572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103573       };
103574     } catch (...) {
103575       {
103576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103577       };
103578     }
103579   }
103580   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103581
103582   return jresult;
103583 }
103584
103585
103586 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
103587   void * jresult ;
103588   std::string *arg1 = 0 ;
103589   Dali::ImageDimensions arg2 ;
103590   Dali::FittingMode::Type arg3 ;
103591   Dali::SamplingMode::Type arg4 ;
103592   Dali::ImageDimensions *argp2 ;
103593   Dali::Devel::PixelBuffer result;
103594
103595   if (!jarg1) {
103596     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103597     return 0;
103598   }
103599   std::string arg1_str(jarg1);
103600   arg1 = &arg1_str;
103601   argp2 = (Dali::ImageDimensions *)jarg2;
103602   if (!argp2) {
103603     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103604     return 0;
103605   }
103606   arg2 = *argp2;
103607   arg3 = (Dali::FittingMode::Type)jarg3;
103608   arg4 = (Dali::SamplingMode::Type)jarg4;
103609   {
103610     try {
103611       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4);
103612     } catch (std::out_of_range& e) {
103613       {
103614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103615       };
103616     } catch (std::exception& e) {
103617       {
103618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103619       };
103620     } catch (...) {
103621       {
103622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103623       };
103624     }
103625   }
103626   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103627
103628   return jresult;
103629 }
103630
103631
103632 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
103633   void * jresult ;
103634   std::string *arg1 = 0 ;
103635   Dali::ImageDimensions arg2 ;
103636   Dali::FittingMode::Type arg3 ;
103637   Dali::ImageDimensions *argp2 ;
103638   Dali::Devel::PixelBuffer result;
103639
103640   if (!jarg1) {
103641     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103642     return 0;
103643   }
103644   std::string arg1_str(jarg1);
103645   arg1 = &arg1_str;
103646   argp2 = (Dali::ImageDimensions *)jarg2;
103647   if (!argp2) {
103648     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103649     return 0;
103650   }
103651   arg2 = *argp2;
103652   arg3 = (Dali::FittingMode::Type)jarg3;
103653   {
103654     try {
103655       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3);
103656     } catch (std::out_of_range& e) {
103657       {
103658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103659       };
103660     } catch (std::exception& e) {
103661       {
103662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103663       };
103664     } catch (...) {
103665       {
103666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103667       };
103668     }
103669   }
103670   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103671
103672   return jresult;
103673 }
103674
103675
103676 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_3(char * jarg1, void * jarg2) {
103677   void * jresult ;
103678   std::string *arg1 = 0 ;
103679   Dali::ImageDimensions arg2 ;
103680   Dali::ImageDimensions *argp2 ;
103681   Dali::Devel::PixelBuffer result;
103682
103683   if (!jarg1) {
103684     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103685     return 0;
103686   }
103687   std::string arg1_str(jarg1);
103688   arg1 = &arg1_str;
103689   argp2 = (Dali::ImageDimensions *)jarg2;
103690   if (!argp2) {
103691     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103692     return 0;
103693   }
103694   arg2 = *argp2;
103695   {
103696     try {
103697       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2);
103698     } catch (std::out_of_range& e) {
103699       {
103700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103701       };
103702     } catch (std::exception& e) {
103703       {
103704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103705       };
103706     } catch (...) {
103707       {
103708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103709       };
103710     }
103711   }
103712   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103713
103714   return jresult;
103715 }
103716
103717
103718 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_4(char * jarg1) {
103719   void * jresult ;
103720   std::string *arg1 = 0 ;
103721   Dali::Devel::PixelBuffer result;
103722
103723   if (!jarg1) {
103724     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103725     return 0;
103726   }
103727   std::string arg1_str(jarg1);
103728   arg1 = &arg1_str;
103729   {
103730     try {
103731       result = Dali::DownloadImageSynchronously((std::string const &)*arg1);
103732     } catch (std::out_of_range& e) {
103733       {
103734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103735       };
103736     } catch (std::exception& e) {
103737       {
103738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103739       };
103740     } catch (...) {
103741       {
103742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103743       };
103744     }
103745   }
103746   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103747
103748   return jresult;
103749 }
103750
103751
103752 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetMaxTextureSize(unsigned int jarg1) {
103753   unsigned int arg1 ;
103754
103755   arg1 = (unsigned int)jarg1;
103756   {
103757     try {
103758       Dali::SetMaxTextureSize(arg1);
103759     } catch (std::out_of_range& e) {
103760       {
103761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103762       };
103763     } catch (std::exception& e) {
103764       {
103765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103766       };
103767     } catch (...) {
103768       {
103769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103770       };
103771     }
103772   }
103773 }
103774
103775
103776 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetMaxTextureSize() {
103777   unsigned int jresult ;
103778   unsigned int result;
103779
103780   {
103781     try {
103782       result = (unsigned int)Dali::GetMaxTextureSize();
103783     } catch (std::out_of_range& e) {
103784       {
103785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103786       };
103787     } catch (std::exception& e) {
103788       {
103789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103790       };
103791     } catch (...) {
103792       {
103793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103794       };
103795     }
103796   }
103797   jresult = result;
103798   return jresult;
103799 }
103800
103801
103802 #ifdef __cplusplus
103803 }
103804 #endif
103805